/// <summary>
        /// Examines mesh objects and logs a description of what it finds right or wrong.
        /// The various properties the function checks for are described in MeshCheckParameters.
        /// </summary>
        /// <param name="meshObjects">A collection of mesh objects.</param>
        /// <param name="textLog">The text log.</param>
        /// <param name="parameters">The mesh checking parameter and results.</param>
        /// <returns>true if successful, false otherwise.</returns>
        /// <since>7.0</since>
        public static bool CheckMeshes(IEnumerable <MeshObject> meshObjects, Rhino.FileIO.TextLog textLog, ref MeshCheckParameters parameters)
        {
            if (null == textLog)
            {
                throw new ArgumentNullException(nameof(textLog));
            }
            var    rharray         = new Runtime.InternalRhinoObjectArray(meshObjects);
            IntPtr ptr_const_array = rharray.NonConstPointer();
            IntPtr ptr_textlog     = textLog.NonConstPointer();

            return(UnsafeNativeMethods.RHC_RhinoCheckMesh2(ptr_const_array, ptr_textlog, ref parameters));
        }
Exemple #2
0
        /// <summary>
        /// </summary>
        /// <param name="filename">full name of file</param>
        /// <param name="dump"></param>
        /// <returns></returns>
        static bool Dump3dmFileHelper(string filename, Rhino.FileIO.TextLog dump)
        {
            dump.Print("====== FILENAME: {0}\n", filename);

            using (Rhino.FileIO.BinaryArchiveFile file = new Rhino.FileIO.BinaryArchiveFile(filename, Rhino.FileIO.BinaryArchiveMode.Read3dm))
            {
                if (!file.Open())
                {
                    dump.Print("**ERROR** Unable to open file.\n");
                    return(false);
                }

                int    version;
                string comment_block;
                if (!file.Reader.Read3dmStartSection(out version, out comment_block))
                {
                    dump.Print("**ERROR** Read3dmStartSection() failed\n");
                    return(false);
                }

                dump.Print("====== VERSION: {0}\n", version);
                dump.Print("====== COMMENT BLOCK:\n");
                dump.Print(comment_block);
                dump.Print("====== CHUNKS:\n");

                while (!file.Reader.AtEnd())
                {
                    uint typecode = file.Reader.Dump3dmChunk(dump);
                    if (typecode == 0)
                    {
                        break;
                    }
                    if (typecode == Rhino.FileIO.File3dmTypeCodes.TCODE_ENDOFFILE)
                    {
                        break;
                    }
                }
                dump.Print("====== FINISHED: {0}\n", filename);
                file.Close();
                return(true);
            }
        }
Exemple #3
0
    static void Main(string[] args)
    {
      if( args.Length < 2 )
      {
        PrintHelp();
        return;
      }

      string output_filename = null;
      bool chunk_dump = false;
      int maximum_directory_depth = 0;
      int file_count = 0;
      const bool bVerboseTextDump = true;

      Rhino.FileIO.TextLog dump = null;

      foreach( string arg in args )
      {
        // check for -out or /out option
        if( (arg.StartsWith("-out:") || arg.StartsWith("/out:")) && arg.Length > "-out:".Length )
        {
          // change destination of dump file
          output_filename = arg.Substring("-out:".Length).Trim();
          continue;
        }
        // check for -chunkdump or /chunkdump option
        if( arg.Equals("-c", StringComparison.OrdinalIgnoreCase) || arg.Equals("/c", StringComparison.OrdinalIgnoreCase) ||
            arg.Equals("-chunk", StringComparison.OrdinalIgnoreCase) || arg.Equals("/chunk", StringComparison.OrdinalIgnoreCase) ||
            arg.Equals("-chunkdump", StringComparison.OrdinalIgnoreCase) || arg.Equals("/chunkdump", StringComparison.OrdinalIgnoreCase) )
        {
          chunk_dump = true;
          continue;
        }
        // check for -recursive or /recursive option
        if( arg.Equals("-r", StringComparison.OrdinalIgnoreCase) || arg.Equals("/r", StringComparison.OrdinalIgnoreCase) ||
            arg.Equals("-recurse", StringComparison.OrdinalIgnoreCase) || arg.Equals("/recurse", StringComparison.OrdinalIgnoreCase) ||
            arg.Equals("-recursive", StringComparison.OrdinalIgnoreCase) || arg.Equals("/recursive", StringComparison.OrdinalIgnoreCase) )
        {
          maximum_directory_depth = 32;
          continue;
        }

        if( System.IO.Directory.Exists(arg) )
        {
          if (dump == null)
          {
            dump = new Rhino.FileIO.TextLog(output_filename);
            dump.IndentSize = 2;
          }

          file_count += ReadDirectoryHelper( 0, maximum_directory_depth, arg, null, bVerboseTextDump, chunk_dump, dump );
        }
        else
        {
          if (dump == null)
          {
            dump = new Rhino.FileIO.TextLog(output_filename);
            dump.IndentSize = 2;
          }

          if (ReadFileHelper(arg, bVerboseTextDump, chunk_dump, dump))
            file_count++;
        }
      }

      string example_read_exe_name = typeof(Program).Assembly.GetName().Name;
      string results = string.Format("{0} read {1} opennurbs model files.\n", example_read_exe_name, file_count);
      if (dump == null)
        Console.WriteLine(results);
      if (dump != null)
      {
        dump.Print(results);
        dump.Dispose();
      }
      Console.WriteLine("press any key to exit");
      Console.ReadKey();
    }
Exemple #4
0
        static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                PrintHelp();
                return;
            }

            string     output_filename         = null;
            bool       chunk_dump              = false;
            int        maximum_directory_depth = 0;
            int        file_count              = 0;
            const bool bVerboseTextDump        = true;

            Rhino.FileIO.TextLog dump = null;

            foreach (string arg in args)
            {
                // check for -out or /out option
                if ((arg.StartsWith("-out:") || arg.StartsWith("/out:")) && arg.Length > "-out:".Length)
                {
                    // change destination of dump file
                    output_filename = arg.Substring("-out:".Length).Trim();
                    continue;
                }
                // check for -chunkdump or /chunkdump option
                if (arg.Equals("-c", StringComparison.OrdinalIgnoreCase) || arg.Equals("/c", StringComparison.OrdinalIgnoreCase) ||
                    arg.Equals("-chunk", StringComparison.OrdinalIgnoreCase) || arg.Equals("/chunk", StringComparison.OrdinalIgnoreCase) ||
                    arg.Equals("-chunkdump", StringComparison.OrdinalIgnoreCase) || arg.Equals("/chunkdump", StringComparison.OrdinalIgnoreCase))
                {
                    chunk_dump = true;
                    continue;
                }
                // check for -recursive or /recursive option
                if (arg.Equals("-r", StringComparison.OrdinalIgnoreCase) || arg.Equals("/r", StringComparison.OrdinalIgnoreCase) ||
                    arg.Equals("-recurse", StringComparison.OrdinalIgnoreCase) || arg.Equals("/recurse", StringComparison.OrdinalIgnoreCase) ||
                    arg.Equals("-recursive", StringComparison.OrdinalIgnoreCase) || arg.Equals("/recursive", StringComparison.OrdinalIgnoreCase))
                {
                    maximum_directory_depth = 32;
                    continue;
                }

                if (System.IO.Directory.Exists(arg))
                {
                    if (dump == null)
                    {
                        dump            = new Rhino.FileIO.TextLog(output_filename);
                        dump.IndentSize = 2;
                    }

                    file_count += ReadDirectoryHelper(0, maximum_directory_depth, arg, null, bVerboseTextDump, chunk_dump, dump);
                }
                else
                {
                    if (dump == null)
                    {
                        dump            = new Rhino.FileIO.TextLog(output_filename);
                        dump.IndentSize = 2;
                    }

                    if (ReadFileHelper(arg, bVerboseTextDump, chunk_dump, dump))
                    {
                        file_count++;
                    }
                }
            }

            string example_read_exe_name = typeof(Program).Assembly.GetName().Name;
            string results = string.Format("{0} read {1} opennurbs model files.\n", example_read_exe_name, file_count);

            if (dump == null)
            {
                Console.WriteLine(results);
            }
            if (dump != null)
            {
                dump.Print(results);
                dump.Dispose();
            }
            Console.WriteLine("press any key to exit");
            Console.ReadKey();
        }
Exemple #5
0
        // Returns: Number of files read
        static int ReadDirectoryHelper(int directoryDepth, int maxDirectoryDepth, string directoryName, string filenameFilter, bool verboseTextDump, bool chunkDump, Rhino.FileIO.TextLog dump)
        {
            int file_count = 0;

            if (directoryDepth <= maxDirectoryDepth)
            {
                if (string.IsNullOrWhiteSpace(filenameFilter))
                {
                    filenameFilter = "*.3dm";
                }

                // read files in this directory
                foreach (string filename in System.IO.Directory.GetFiles(directoryName, filenameFilter))
                {
                    if (ReadFileHelper(filename, verboseTextDump, chunkDump, dump))
                    {
                        file_count++;
                    }
                }

                // read files in subdirectories
                foreach (string dir in System.IO.Directory.GetDirectories(directoryName))
                {
                    file_count += ReadDirectoryHelper(directoryDepth + 1, maxDirectoryDepth, dir, filenameFilter, verboseTextDump, chunkDump, dump);
                }
            }
            return(file_count);
        }
Exemple #6
0
        // Returns: True if .3dm file was successfully read into a File3dmModel class.
        static bool ReadFileHelper(string filename, bool verboseTextDump, bool chunkDump, Rhino.FileIO.TextLog dump)
        {
            if (chunkDump)
            {
                return(Dump3dmFileHelper(filename, dump));
            }

            dump.Print("\nOpenNURBS Archive File:  {0}\n", filename);

            // open file containing opennurbs archive
            Rhino.FileIO.File3dm model = Rhino.FileIO.File3dm.Read(filename);
            if (model == null)
            {
                dump.Print("  Unable to open file.\n");
                return(false);
            }

            dump.PopIndent(); dump.PopIndent(); dump.PopIndent(); dump.PopIndent(); dump.PopIndent(); dump.PopIndent(); dump.PopIndent();

            dump.PushIndent();

            // print diagnostic
            dump.Print("Successfully read.\n");

            // see if everything is in good shape
            if (model.IsValid(dump))
            {
                dump.Print("Model is valid.\n");
            }
            else
            {
                dump.Print("Model is not valid.\n");
            }

            // create a text dump of the model
            if (verboseTextDump)
            {
                dump.PushIndent();
                model.DumpToTextLog(dump);
                dump.PopIndent();
            }

            // destroy this model
            model.Dispose();

            dump.PopIndent();
            return(true);
        }
Exemple #7
0
        /// <summary>
        /// Compare intersection events.
        /// </summary>
        /// <param name="eventA">The first intersection event to compare.</param>
        /// <param name="eventB">The second intersection event to compare.</param>
        /// <param name="relativePointTolerance">The comparison tolerance. If RhinoMath.UnsetValue, then RhinoMath.SqrtEpsilon is used.</param>
        /// <param name="log">If not null and false is returned, then a description of the error is appended to log.</param>
        /// <returns></returns>
        public static bool CompareEquivalent(IntersectionEvent eventA, IntersectionEvent eventB, double relativePointTolerance, Rhino.FileIO.TextLog log)
        {
            // compare to match
            if (relativePointTolerance == RhinoMath.UnsetValue)
            {
                relativePointTolerance = RhinoMath.SqrtEpsilon;
            }

            bool rc = true;

            if (eventA.m_type != eventB.m_type)
            {
                if (log != null)
                {
                    log.Print("Event types mismatch.");
                }
                rc = false;
            }
            else
            {
                for (int ei = 0; ei < 2; ei++)
                {
                    if (ei == 1 && eventA.m_type != 4) // ON_X_EVENT::TYPE::csx_overlap
                    {
                        continue;
                    }

                    Point3d AActual = (ei == 0) ? eventA.m_A0 : eventA.m_A1;
                    Point3d BActual = (ei == 0) ? eventA.m_B0 : eventA.m_B1;
                    Point3d AExp    = (ei == 0) ? eventB.m_A0 : eventB.m_A1;
                    Point3d BExp    = (ei == 0) ? eventB.m_B0 : eventB.m_B1;

                    double sz   = AExp.MaximumCoordinate;
                    double dist = AActual.DistanceTo(AExp);
                    if (dist > relativePointTolerance * (1 + sz))
                    {
                        if (log != null)
                        {
                            log.Print("Event mismatch. Distance between expected and actual m_A{0} was {1}.\n", ei * 2, dist);
                        }
                        rc = false;
                    }

                    dist = BActual.DistanceTo(BExp);
                    if (dist > relativePointTolerance * (1 + sz))
                    {
                        if (log != null)
                        {
                            log.Print("Event mismatch. Distance between expected and actual m_B{0} was {1}.\n", ei * 2, dist);
                        }
                        rc = false;
                    }
                }
            }
            return(rc);
        }