Updates the control network io to work directly off the graph object.

    return

def to_isis(path, C, mode='w', version=VERSION,

def to_isis(path, network, mode='w', version=VERSION,

            headerstartbyte=HEADERSTARTBYTE,

            networkid='None', targetname='None',

            description='None', username=DEFAULTUSERNAME):

    if isinstance(path, str):

        with IsisStore(path, mode) as store:

            point_messages, point_sizes = store.create_points(C)

            point_messages, point_sizes = store.create_points(network)

            points_bytes = sum(point_sizes)

            buffer_header, buffer_header_size = store.create_buffer_header(C, networkid,

            buffer_header, buffer_header_size = store.create_buffer_header(network, networkid,

                                                                           targetname,

                                                                           description,

                                                                           username,

                store.write(point, point_start_offset)

                point_start_offset += point_sizes[i]

            header = store.create_pvl_header(C, version, headerstartbyte, networkid,

            header = store.create_pvl_header(network, version, headerstartbyte, networkid,

                                             targetname, description, username,

                                             buffer_header_size, points_bytes)

class IsisStore(object):

    """

    Class to manage IO of an ISIS control network (version 2).

    Attributes

    ----------

    pointid : int

              The current index to be assigned to newly added points

    """

    def __init__(self, path, mode=None, **kwargs):

        self.pointid = 0

        self.nmeasures = 0

        self._path = path

        if not mode:

            mode = 'a' # pragma: no cover

        """

        point_sizes = []

        point_messages = []

        for pid, measure_list in cnet.point_to_correspondence.items():

        for i, node in cnet.nodes(data=True):

            for pid, measure_list in node.point_to_correspondence.items():

                point_spec = cnf.ControlPointFileEntryV0002()

            point_spec.id = str(pid)

                point_spec.id = str(self.pointid)

                point_spec.type = pid.point_type

                # The reference index should always be the image with the lowest index

                    measure_spec.line = float(m.y)

                    measure_iterable.append(measure_spec)

                    self.nmeasures += 1

                point_spec.measures.extend(measure_iterable)

                point_message = point_spec.SerializeToString()

                point_sizes.append(point_spec.ByteSize())

                point_messages.append(point_message)

                self.pointid += 1

            return point_messages, point_sizes

    def create_buffer_header(self, cnet, networkid, targetname,

                        ('Created', cnet.creationdate),

                        ('LastModified', cnet.modifieddate),

                        ('Description', description),

                        ('NumberOfPoints', cnet.n_points),

                        ('NumberOfMeasures', cnet.n_measures),

                        ('NumberOfPoints', self.pointid),

                        ('NumberOfMeasures', self.nmeasures),

                        ('Version', version)

                        ])

                  }),