How to use the ice.Ice.ObjectPrx function in ice

"setCameraDescription": [, , , , , [3], [["jderobot.CameraDescription", true]], , , true, ],
        "startCameraStreaming": [, , , , , [7], , , , , ],
        "stopCameraStreaming": [, , , , , , , , , , ],
        "reset": [, , , , , , , , , , ]
    });

    jderobot.SetterCamera = Slice.defineObject(
        undefined,
        Ice.Object, undefined, 1,
        [
            "::Ice::Object",
            "::jderobot::SetterCamera"
        ],
        -1, undefined, undefined, false);

    jderobot.SetterCameraPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.SetterCamera.ice_staticId, undefined);

    Slice.defineOperations(jderobot.SetterCamera, jderobot.SetterCameraPrx,
    {
        "setCamera": [, , , , , [3], [["jderobot.CameraPrx"]], , , , ]
    });
    exports.jderobot = jderobot;
}
(typeof(global) !== "undefined" && typeof(global.process) !== "undefined" ? module : undefined,

false);

    jderobot.ImageDataPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.ImageData.ice_staticId, undefined);

    Slice.defineOperations(jderobot.ImageData, jderobot.ImageDataPrx);

    jderobot.ImageConsumer = Slice.defineObject(
        undefined,
        Ice.Object, undefined, 1,
        [
            "::Ice::Object",
            "::jderobot::ImageConsumer"
        ],
        -1, undefined, undefined, false);

    jderobot.ImageConsumerPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.ImageConsumer.ice_staticId, undefined);

    Slice.defineOperations(jderobot.ImageConsumer, jderobot.ImageConsumerPrx,
    {
        "report": [, , , , , , [["jderobot.ImageData", true]], , , true, ]
    });
    Slice.defineSequence(jderobot, "ImageFormatHelper", "Ice.StringHelper", false);

    /**
     * Interface to the image provider.
     **/
    jderobot.ImageProvider = Slice.defineObject(
        undefined,
        Ice.Object, undefined, 1,
        [
            "::Ice::Object",
            "::jderobot::ImageProvider"

var jderobot = __M.module("jderobot");

    /**
     * Interface to the Gazebo Motors Actuators interaction.
     **/
    jderobot.Motors = Slice.defineObject(
        undefined,
        Ice.Object, undefined, 1,
        [
            "::Ice::Object",
            "::jderobot::Motors"
        ],
        -1, undefined, undefined, false);

    jderobot.MotorsPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.Motors.ice_staticId, undefined);

    Slice.defineOperations(jderobot.Motors, jderobot.MotorsPrx,
    {
        "getV": [, , , , , [5], , , , , ],
        "setV": [, , , , , [3], [[5]], , , , ],
        "getW": [, , , , , [5], , , , , ],
        "setW": [, , , , , [3], [[5]], , , , ],
        "getL": [, , , , , [5], , , , , ],
        "setL": [, , , , , [3], [[5]], , , , ]
    });

    jderobot.SetterMotors = Slice.defineObject(
        undefined,
        Ice.Object, undefined, 1,
        [
            "::Ice::Object",

this.fdistx = __is.readFloat();
            this.fdisty = __is.readFloat();
            this.u0 = __is.readFloat();
            this.v0 = __is.readFloat();
            this.skew = __is.readFloat();
            this.posx = __is.readFloat();
            this.posy = __is.readFloat();
            this.posz = __is.readFloat();
            this.foax = __is.readFloat();
            this.foay = __is.readFloat();
            this.foaz = __is.readFloat();
            this.roll = __is.readFloat();
        },
        false);

    jderobot.CameraDescriptionPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.CameraDescription.ice_staticId, undefined);

    Slice.defineOperations(jderobot.CameraDescription, jderobot.CameraDescriptionPrx);

    /**
     * Camera interface
     **/
    jderobot.Camera = Slice.defineObject(
        undefined,
        Ice.Object,
        [
            jderobot.ImageProvider
        ], 1,
        [
            "::Ice::Object",
            "::jderobot::Camera",
            "::jderobot::ImageProvider"

"getW": [, , , , , [5], , , , , ],
        "setW": [, , , , , [3], [[5]], , , , ],
        "getL": [, , , , , [5], , , , , ],
        "setL": [, , , , , [3], [[5]], , , , ]
    });

    jderobot.SetterMotors = Slice.defineObject(
        undefined,
        Ice.Object, undefined, 1,
        [
            "::Ice::Object",
            "::jderobot::SetterMotors"
        ],
        -1, undefined, undefined, false);

    jderobot.SetterMotorsPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.SetterMotors.ice_staticId, undefined);

    Slice.defineOperations(jderobot.SetterMotors, jderobot.SetterMotorsPrx,
    {
        "setMotors": [, , , , , [3], [["jderobot.MotorsPrx"]], , , , ]
    });
    exports.jderobot = jderobot;
}
(typeof(global) !== "undefined" && typeof(global.process) !== "undefined" ? module : undefined,

__os.writeInt(this.height);
            __os.writeInt(this.size);
            __os.writeString(this.format);
            __os.writeString(this.md5sum);
        },
        function(__is)
        {
            this.width = __is.readInt();
            this.height = __is.readInt();
            this.size = __is.readInt();
            this.format = __is.readString();
            this.md5sum = __is.readString();
        },
        false);

    jderobot.ImageDescriptionPrx = Slice.defineProxy(Ice.ObjectPrx, jderobot.ImageDescription.ice_staticId, undefined);

    Slice.defineOperations(jderobot.ImageDescription, jderobot.ImageDescriptionPrx);

    /**
     * A single image served as a sequence of bytes
     **/
    jderobot.ImageData = Slice.defineObject(
        function(timeStamp, description, pixelData)
        {
            Ice.Object.call(this);
            this.timeStamp = timeStamp !== undefined ? timeStamp : new jderobot.Time();
            this.description = description !== undefined ? description : null;
            this.pixelData = pixelData !== undefined ? pixelData : null;
        },
        Ice.Object, undefined, 1,
        [