load_image_plane

class ImagePlaneLoader(plugin.Loader):
    """Specific loader of plate for image planes on selected camera."""

    product_types = {"image", "plate", "render"}
    label = "Load imagePlane"
    representations = {"mov", "exr", "preview", "png", "jpg", "jpeg"}
    icon = "image"
    color = "orange"

    def load(self, context, name, namespace, data, options=None):

        image_plane_depth = 1000
        folder_name = context["folder"]["name"]
        namespace = namespace or unique_namespace(
            folder_name + "_",
            prefix="_" if folder_name[0].isdigit() else "",
            suffix="_",
        )

        # Get camera from user selection.
        # is_static_image_plane = None
        # is_in_all_views = None
        camera = data.get("camera") if data else None

        if not camera:
            cameras = cmds.ls(type="camera")

            # Cameras by names
            camera_names = {}
            for camera in cameras:
                parent = cmds.listRelatives(camera, parent=True, path=True)[0]
                camera_names[parent] = camera

            camera_names["Create new camera."] = "create-camera"
            window = CameraWindow(camera_names.keys())
            window.exec_()
            # Skip if no camera was selected (Dialog was closed)
            if window.camera not in camera_names:
                return
            camera = camera_names[window.camera]

        if camera == "create-camera":
            camera = cmds.createNode("camera")

        if camera is None:
            return

        try:
            cmds.setAttr("{}.displayResolution".format(camera), True)
            cmds.setAttr("{}.farClipPlane".format(camera),
                         image_plane_depth * 10)
        except RuntimeError:
            pass

        # Create image plane
        with namespaced(namespace):
            # Create inside the namespace
            image_plane_transform, image_plane_shape = cmds.imagePlane(
                fileName=self.filepath_from_context(context),
                camera=camera
            )

        # Set colorspace
        colorspace = self.get_colorspace(context["representation"])
        if colorspace:
            cmds.setAttr(
                "{}.ignoreColorSpaceFileRules".format(image_plane_shape),
                True
            )
            cmds.setAttr("{}.colorSpace".format(image_plane_shape),
                         colorspace, type="string")

        # Set offset frame range
        start_frame = cmds.playbackOptions(query=True, min=True)
        end_frame = cmds.playbackOptions(query=True, max=True)

        for attr, value in {
            "depth": image_plane_depth,
            "frameOffset": 0,
            "frameIn": start_frame,
            "frameOut": end_frame,
            "frameCache": end_frame,
            "useFrameExtension": True
        }.items():
            plug = "{}.{}".format(image_plane_shape, attr)
            cmds.setAttr(plug, value)

        movie_representations = {"mov", "preview"}
        if context["representation"]["name"] in movie_representations:
            cmds.setAttr(image_plane_shape + ".type", 2)

        # Ask user whether to use sequence or still image.
        if context["representation"]["name"] == "exr":
            # Ensure OpenEXRLoader plugin is loaded.
            cmds.loadPlugin("OpenEXRLoader", quiet=True)

            message = (
                "Hold image sequence on first frame?"
                "\n{} files available.".format(
                    len(context["representation"]["files"])
                )
            )
            reply = QtWidgets.QMessageBox.information(
                None,
                "Frame Hold.",
                message,
                QtWidgets.QMessageBox.Yes,
                QtWidgets.QMessageBox.No
            )
            if reply == QtWidgets.QMessageBox.Yes:
                frame_extension_plug = "{}.frameExtension".format(image_plane_shape)  # noqa

                # Remove current frame expression
                disconnect_inputs(frame_extension_plug)

                cmds.setAttr(frame_extension_plug, start_frame)

        new_nodes = [image_plane_transform, image_plane_shape]

        return containerise(
            name=name,
            namespace=namespace,
            nodes=new_nodes,
            context=context,
            loader=self.__class__.__name__
        )

    def update(self, container, context):
        folder_entity = context["folder"]
        repre_entity = context["representation"]

        members = get_container_members(container)
        image_planes = cmds.ls(members, type="imagePlane")
        assert image_planes, "Image plane not found."
        image_plane_shape = image_planes[0]

        path = get_representation_path(repre_entity)
        cmds.setAttr("{}.imageName".format(image_plane_shape),
                     path,
                     type="string")
        cmds.setAttr("{}.representation".format(container["objectName"]),
                     repre_entity["id"],
                     type="string")

        colorspace = self.get_colorspace(repre_entity)
        if colorspace:
            cmds.setAttr(
                "{}.ignoreColorSpaceFileRules".format(image_plane_shape),
                True
            )
            cmds.setAttr("{}.colorSpace".format(image_plane_shape),
                         colorspace, type="string")

        # Set frame range.
        start_frame = folder_entity["attrib"]["frameStart"]
        end_frame = folder_entity["attrib"]["frameEnd"]

        for attr, value in {
            "frameOffset": 0,
            "frameIn": start_frame,
            "frameOut": end_frame,
            "frameCache": end_frame
        }:
            plug = "{}.{}".format(image_plane_shape, attr)
            cmds.setAttr(plug, value)

    def switch(self, container, context):
        self.update(container, context)

    def remove(self, container):
        members = cmds.sets(container['objectName'], query=True)
        cmds.lockNode(members, lock=False)
        cmds.delete([container['objectName']] + members)

        # Clean up the namespace
        try:
            cmds.namespace(removeNamespace=container['namespace'],
                           deleteNamespaceContent=True)
        except RuntimeError:
            pass

    def get_colorspace(self, representation):

        data = representation.get("data", {}).get("colorspaceData", {})
        if not data:
            return

        colorspace = data.get("colorspace")
        return colorspace