Beispiel #1
0
        /* -------------------------------------------------------------------- */
        /*      Reading the Fields in this Feature                              */
        /* -------------------------------------------------------------------- */

        public static void CreateTreeFields(ref TreeNode thisFeatureTree, Feature feature, FeatureDefn featureDefn)
        {
            // field definition as we iterate through the fields
            FieldDefn iFieldDefn;
            int       nameIndex;
            int       objlIndex;
            string    nameString;
            string    objlString;

            // To get the name and the S-57 Type code (OBJL), we have to look forward into the fields.  This piece of code
            // is mostly here to show how that is done as will need this when rendering these objects.  You could easily add
            // shapes or color, but it is not necessary here.  The name and the code is nice for the debug file though so we can
            // see what each feature is.

            // OBJL field should always exist - the exception are the meta data fields such as DSID which has no code.
            objlIndex = featureDefn.GetFieldIndex("OBJL");
            if (objlIndex > 0)
            {
                objlString = DecodeField(feature, featureDefn.GetFieldDefn(objlIndex), objlIndex);
            }
            else
            {
                objlString = "No Code";
            }

            // name field may not exist.  we could get either the info or text description if they exist
            nameIndex = featureDefn.GetFieldIndex("OBJNAM");
            if (nameIndex > 0)
            {
                nameString = DecodeField(feature, featureDefn.GetFieldDefn(nameIndex), nameIndex);
            }
            else
            {
                nameString = "Not Named";
            }

            DebugUtil.WriteLine();
            DebugUtil.WriteLine(string.Format("   *** Feature: {0}, Name: {1}, S-57 Code: {2}", featureDefn.GetName(), nameString, objlString));
            DebugUtil.WriteLine();

            // get the styles, if any
            if (feature.GetStyleString() != null)
            {
                DebugUtil.WriteLine("  Style = " + feature.GetStyleString());
            }

            // this gets the sub-geometries.  not all features have sub-geometries
            Geometry geom = feature.GetGeometryRef();

            if (geom != null)
            {
                DebugUtil.WriteLine("   Geometry Name: " + geom.GetGeometryName() + " Sub-geometry Count: " + geom.GetGeometryCount());

                Geometry sub_geom;
                for (int i = 0; i < geom.GetGeometryCount(); i++)
                {
                    sub_geom = geom.GetGeometryRef(i);
                    if (sub_geom != null)
                    {
                        string subGeoString;
                        DebugUtil.Write("   sub-geometry " + i + ": ");
                        switch (sub_geom.GetGeometryType())
                        {
                        case wkbGeometryType.wkbLineString:
                        case wkbGeometryType.wkbPoint25D:
                            sub_geom.ExportToWkt(out subGeoString);
                            DebugUtil.WriteLine(subGeoString);
                            TreeUtil.AddChildNode(thisFeatureTree, subGeoString);
                            break;

                        default:
                            DebugUtil.WriteLine("Unhandled subgeometry type: " + sub_geom.GetGeometryType());
                            TreeUtil.AddChildNode(thisFeatureTree, "Unhandled sub-geomtry type", sub_geom.GetGeometryType().ToString());
                            break;
                        }
                    }
                }

                // a bit confusing, but if it has no sub geometries, use the base geometry.  mostly applies to the type POINT
                if (geom.GetGeometryCount() == 0)
                {
                    string geom_wkt;
                    geom.ExportToWkt(out geom_wkt);
                    DebugUtil.WriteLine("   geom_wkt: " + geom_wkt);
                    TreeUtil.AddChildNode(thisFeatureTree, geom_wkt);
                }
            }  // if geo != null

            for (int iField = 0; iField < feature.GetFieldCount(); iField++)
            {
                iFieldDefn = featureDefn.GetFieldDefn(iField);

                // not all fields have usable information, skip those that don't.
                if (feature.IsFieldSet(iField))  // IsFieldSet is a handy way to see if the field has any actual information
                {
                    DebugUtil.Write("   ");
                    DebugUtil.Write("Field Name: " + iFieldDefn.GetName() + ", ");
                    DebugUtil.Write("Type Name: " + iFieldDefn.GetFieldTypeName(iFieldDefn.GetFieldType()) + ", ");
                    DebugUtil.Write("Field Type: " + iFieldDefn.GetFieldType() + ", ");
                    DebugUtil.Write("Value: " + DecodeField(feature, iFieldDefn, iField));
                    DebugUtil.WriteLine();
                }  // if isField
            }
        }
Beispiel #2
0
        /* --------------------------------------------------------------------
         *      Reading the Field Definitions.
         *
         *  These define how to interpret the Features (next section).  They do
         *  do not need to be added to the tree, but are used to interpret the
         *  Features.
         *
         * --------------------------------------------------------------------*/

        protected static void CreateTreeFeatures(TreeNode parentLayerTree, Layer thisLayer)
        {
            FeatureDefn featureDefn;

            //
            // These are fields from the DSID layer.  They have odd names, but we need this data.
            //
            string[] DSIDList = { "DSID_EXPP", "DSID_INTU", "DSID_DSNM", "DSID_EDTN", "DSID_UPDN", "DSID_UADT", "DSID_ISDT", "DSID_STED", "DSID_PRSP", "DSID_PSDN",
                                  "DSID_PRED", "DSID_PROF", "DSID_AGEN", "DSID_COMT", "DSSI_DSTR", "DSSI_AALL", "DSSI_NALL", "DSSI_NOMR", "DSSI_NOCR", "DSSI_NOGR","DSSI_NOLR",
                                  "DSSI_NOIN", "DSSI_NOCN", "DSSI_NOED", "DSSI_NOFA", "DSPM_HDAT", "DSPM_VDAT", "DSPM_SDAT", "DSPM_CSCL", "DSPM_DUNI", "DSPM_HUNI","DSPM_PUNI",
                                  "DSPM_COUN", "DSPM_COMF", "DSPM_SOMF", "DSPM_COMT" };

            // This is the list of feature fields used to contain names.  Not all objects are nameed.  Some that are not named have useful comments.
            // This is order dependenet.
            string[] featureNameList = { "OBJNAM", "CATSEA", "CATLND" };

            Feature   feature;
            TreeNode  featureTree;
            FieldDefn fieldDefn;
            int       objIndex;                 // index used to search within fields
            string    fieldName;                // name of a specific field
            string    fieldValue;               // value for a specific field

#if false
            // there is litte point in adding the field defintions to the tree or the output files other than diagnostics
            // if you want to turn this on change or remove the #if/#endif.  FYI it makes bot the file and the tree much larger
            // and therefore slower to build and display.

            FieldDefn fieldDefn;        // variable for local fields

            // DebugUtil.WriteLine("   ***  Field Definitions  ***");
            for (int iAttr = 0; iAttr < featureDefn.GetFieldCount(); iAttr++)
            {
                // get the collection of field information
                fieldDefn = featureDefn.GetFieldDefn(iAttr);

                // add a new local root node to hold this field and give it this field name

                thisFieldRoot = new TreeNode(fieldDefn.GetName());

                TreeUtil.AddChildNode(thisFieldRoot, "Field Name", fieldDefn.GetName());
                TreeUtil.AddChildNode(thisFieldRoot, "Name Ref", fieldDefn.GetNameRef());
                TreeUtil.AddChildNode(thisFieldRoot, "Type Name", fieldDefn.GetTypeName());
                TreeUtil.AddChildNode(thisFieldRoot, "Field Type", fieldDefn.GetFieldType().ToString());
                TreeUtil.AddChildNode(thisFieldRoot, "Width", fieldDefn.GetWidth().ToString());
                TreeUtil.AddChildNode(thisFieldRoot, "Precision", fieldDefn.GetPrecision().ToString());
                fieldDefn.GetTypeName();
                thisLayerRoot.Nodes.Add(thisFieldRoot);

                DebugUtil.WriteLine("   " + "NameRef: " + fieldDefn.GetNameRef() + ": " +
                                    "Type: " + fieldDefn.GetFieldType() +
                                    "Type Name: " + fieldDefn.GetFieldTypeName(fieldDefn.GetFieldType()) + " (" +
                                    fieldDefn.GetWidth() + "." +
                                    fieldDefn.GetPrecision() + ")");
            }
#endif

            /* -------------------------------------------------------------------- */
            /*      Reading the Features                                            */
            /* -------------------------------------------------------------------- */

            // Get the FeatureDefn pointer for this layer
            featureDefn = thisLayer.GetLayerDefn();

            // get the feature list for this layer
            feature = new Feature(featureDefn);

            while ((feature = thisLayer.GetNextFeature()) != null)
            {
                // create the subtree and name it
                featureTree = new TreeNode();

                // get the field name.  Most lights have names as do some bouys, bridges and other landmarks.  The featureNameList controls the fields
                // we look for names in.  Most feature do NOT have names.
                fieldName = "";
                foreach (string field in featureNameList)
                {
                    if ((objIndex = featureDefn.GetFieldIndex(field)) >= 0)
                    {
                        // if the name is already found, do not reassign it
                        if (fieldName == "")
                        {
                            fieldDefn = featureDefn.GetFieldDefn(objIndex);
                            fieldName = DecodeField(feature, fieldDefn, objIndex);
                            if (fieldName != null && fieldName != "")
                            {
                                featureTree.Name = fieldName;
                                featureTree.Text = featureTree.Name;
                            }
                        }
                    }
                }

                // if no name is found above, assign it "unnamed" unless the layer is DSID
                if (fieldName == "" & thisLayer.GetName() != "DSID")
                {
                    fieldName        = "Unnamed";
                    featureTree.Name = fieldName;
                    featureTree.Text = featureTree.Name;
                }

                // DSID has to be handled differently. It has not displayable data and has it's own fieldlist
                if (thisLayer.GetName() == "DSID")
                {
                    foreach (string field in DSIDList)
                    {
                        if ((objIndex = featureDefn.GetFieldIndex(field)) >= 0)
                        {
                            fieldDefn  = featureDefn.GetFieldDefn(objIndex);
                            fieldValue = DecodeField(feature, fieldDefn, objIndex);
                            // field values are never 0
                            if (fieldValue != null && fieldValue != "")
                            {
                                TreeUtil.AddChildNode(parentLayerTree, field, fieldValue);
                            }
                        }
                    }
                }
                else
                {
                    // The fieldList contains the names of the fields are interested in.  We do not want all fields as many of them are
                    // irrelevant to diplaying the image such as the agency names and quality of the data, etc.

                    foreach (string field in fieldList)
                    {
                        // check each feature for the key attributes and add them to the tree if they exist.
                        if ((objIndex = featureDefn.GetFieldIndex(field)) >= 0)
                        {
                            if (feature.IsFieldSet(objIndex))
                            {
                                fieldDefn  = featureDefn.GetFieldDefn(objIndex);
                                fieldValue = DecodeField(feature, fieldDefn, objIndex);
                                // valid field values are never 0 or empty
                                if (fieldValue != null && fieldValue != "")
                                {
                                    TreeUtil.AddChildNode(featureTree, field, fieldValue);
                                }
                            }
                        }
                    }
                }

                // get the details of the fields.  This is mostly diagnostic code, but it does populate the tree with positional information
                CreateTreeFields(ref featureTree, feature, featureDefn);

                // add the subtree
                parentLayerTree.Nodes.Add(featureTree);
                feature.Dispose();
            }
        }
Beispiel #3
0
        /// <summary>
        /// Iterates through the layers of the map and builds a tree based on the layer information
        /// </summary>
        /// <param name="ds"></param>
        /// <returns>"TreeNode"</returns>
        ///
        public static TreeNode CreateTree()
        {
            DebugUtil.WriteLine();
            DebugUtil.WriteLine("*******************************************************************************************************");
            DebugUtil.WriteLine("****                                      Building Tree                                            ****");
            DebugUtil.WriteLine("*******************************************************************************************************");
            DebugUtil.WriteLine();


            TreeNode topNode  = new TreeNode();
            TreeNode metaTree = new TreeNode();
            Layer    layer;
            string   srs_wkt;
            Envelope thisEnvelope = new Envelope();
            string   coordinateString;

            // add the name of the chart as the name of this root
            topNode.Text = Path.GetFileName(ds.name);
            topNode.Name = Path.GetFileName(ds.name);

            // Meta Tree
            metaTree.Text = "Meta Data";
            metaTree.Name = "Meta Data";

            // get layer 0 (should be "DSID) for the meta data
            layer = ds.GetLayerByIndex(0);

            /* -------------------------------------------------------------------- */
            /* Get the spatial reference.  It is consistent for the entire map so we*/
            /* only need to do it once.                                             */
            /* -------------------------------------------------------------------- */

            OSGeo.OSR.SpatialReference sr = layer.GetSpatialRef();
            // this should not be null
            if (sr != null)
            {
                sr.ExportToPrettyWkt(out srs_wkt, 1);
                TreeUtil.AddChildNode(metaTree, "Spatial Reference", srs_wkt);
                DebugUtil.WriteLine("Spatial Reference: " + srs_wkt);
            }
            else
            {
                TreeUtil.AddChildNode(metaTree, "Spatial Reference", "Spatial Reference Uknown");
                srs_wkt = "SRS: Unknown.";
            }

            // get Envelope for this layer
            layer.GetExtent(thisEnvelope, 1);

            // Get the Extents for the map.  Again, they are consistent for the entire map, so we only need to do this once.
            if (thisEnvelope != null)
            {
                coordinateString = String.Format("MaxX = {0}, MaxY = {1}, MinX = {2}, MinY = {3}.", thisEnvelope.MaxX, thisEnvelope.MaxY, +thisEnvelope.MinX, thisEnvelope.MinY);
                DebugUtil.WriteLine("Extents: " + coordinateString);
                TreeUtil.AddChildNode(metaTree, "Envelope: ", coordinateString);
            }

            // add metaTree to topNode
            topNode.Nodes.Add(metaTree);

            // go through all the layers starting at zero
            for (int i = 0; i < ds.GetLayerCount(); i++)
            {
                layer = ds.GetLayerByIndex(i);
                if (layer != null)
                {
                    // most of the work is done here
                    CreateTreeLayers(topNode, layer, i);
                }
                else
                {
                    DebugUtil.WriteLine("***********    Critical Error     *************");
                    DebugUtil.WriteLine("Layer: " + i + " is null and does not exist.");
                    MessageBox.Show("Critical Error: " + "Layer: " + i + " is null and does not exist.");
                }
            }

            DebugUtil.WriteLine("   TopNode node count is " + topNode.Nodes.Count + ".");

            // save the tree to a file.  this is controlled by the debug flags.  note that the file can get very large
            TreeUtil.OpenPrintRecursive("TreeNode.txt");
            TreeUtil.PrintRecursive(topNode);

            // close the debug files
            DebugUtil.Close();
            TreeUtil.Close();

            return(topNode);
        }