public override void postprocess_target_objects()
        {
            bool is_closed = true;

            if (InputSOs.Count == 1)
            {
                is_closed    = InputSOs[0].Mesh.CachedIsClosed;
                MaxDimension = InputSOs[0].Mesh.CachedBounds.MaxDim / base.sceneToObjUnitScale;
            }
            else
            {
                foreach (var so in InputSOs)
                {
                    is_closed = is_closed && so.Mesh.CachedIsClosed;
                }
                MaxDimension = base.combineMesh.CachedBounds.MaxDim;
            }

            //if (is_closed == false)
            GenerateClosedOp.ClosingType = GenerateClosedMeshOp.ClosingTypes.WindingNumberGrid;

            double cell_size = ToolDefaults.DefaultVoxelSceneSizeF(new AxisAlignedBox3d(MaxDimension, MaxDimension, MaxDimension));;

            set_grid_cell_size(cell_size);
            set_mesh_cell_size(cell_size);
            set_min_comp_size(2.0);
        }
Example #2
0
        public override void postprocess_target_objects()
        {
            bool is_closed = true;

            if (InputSOs.Count == 1)
            {
                is_closed    = InputSOs[0].Mesh.CachedIsClosed;
                MaxDimension = InputSOs[0].Mesh.CachedBounds.MaxDim / base.sceneToObjUnitScale;
            }
            else
            {
                foreach (var so in InputSOs)
                {
                    is_closed = is_closed && so.Mesh.CachedIsClosed;
                }
                MaxDimension = base.combineMesh.CachedBounds.MaxDim;
            }

            ShellOp.ShellType = (is_closed) ?
                                MeshShellOp.ShellTypes.DistanceField : MeshShellOp.ShellTypes.Extrusion;

            double cell_size = ToolDefaults.DefaultVoxelSceneSizeF(new AxisAlignedBox3d(MaxDimension, MaxDimension, MaxDimension));;

            set_grid_cell_size(cell_size);
            set_mesh_cell_size(cell_size);
            set_min_comp_size(2.0);

            show_original = is_closed;

            fOuterPreviewMaterial = OuterPreviewMaterial.ToFMaterial();
        }
Example #3
0
        public override void postprocess_target_objects()
        {
            bool is_closed = true;

            if (InputSOs.Count == 1)
            {
                is_closed    = InputSOs[0].Mesh.CachedIsClosed;
                MaxDimension = InputSOs[0].Mesh.CachedBounds.MaxDim / base.sceneToObjUnitScale;
            }
            else
            {
                foreach (var so in InputSOs)
                {
                    is_closed = is_closed && so.Mesh.CachedIsClosed;
                }
                MaxDimension = base.combineMesh.CachedBounds.MaxDim;
            }

            MorphOp.OpType = MeshMorphologyOp.OperationTypes.Dilate;

            double cell_size = ToolDefaults.DefaultVoxelSceneSizeF(new AxisAlignedBox3d(MaxDimension, MaxDimension, MaxDimension));;

            set_grid_cell_size(cell_size);
            set_mesh_cell_size(cell_size);
            set_min_comp_size(2.0);

            set_distance(1.0);
        }
Example #4
0
        public override void postprocess_target_objects()
        {
            bool is_closed = true;

            if (InputSOs.Count == 1)
            {
                is_closed    = InputSOs[0].Mesh.CachedIsClosed;
                MaxDimension = InputSOs[0].Mesh.CachedBounds.MaxDim / base.sceneToObjUnitScale;
            }
            else
            {
                foreach (var so in InputSOs)
                {
                    is_closed = is_closed && so.Mesh.CachedIsClosed;
                }
                MaxDimension = base.combineMesh.CachedBounds.MaxDim;
            }

            double cell_size = 0.5 * ToolDefaults.DefaultVoxelSceneSizeF(new AxisAlignedBox3d(MaxDimension, MaxDimension, MaxDimension));

            set_grid_cell_size(cell_size);
            set_mesh_cell_size(cell_size);
            set_min_comp_size(2.0);
            set_wall_thickness(2.4);
            set_infill_thickness(2.0);
            set_infill_spacing(10.0);

            show_original = is_closed;

            fOuterPreviewMaterial = OuterPreviewMaterial.ToFMaterial();
        }
Example #5
0
        public override void postprocess_target_objects()
        {
            double max_scene_dim = TargetObjects[0].SO.Mesh.CachedBounds.MaxDim / TargetObjects[0].sceneToObjUnitScale;
            double scene_length  = ToolDefaults.DefaultTargetEdgeLengthF(max_scene_dim);

            set_target_edge_length(scene_length);
            set_max_distance(1.0);
        }
Example #6
0
        public override void postprocess_target_objects()
        {
            double max_scene_dim = 0;

            foreach (var target in TargetObjects)
            {
                max_scene_dim = Math.Max(max_scene_dim, target.SO.Mesh.CachedBounds.MaxDim / target.sceneToObjUnitScale);
            }
            double scene_length = ToolDefaults.DefaultTargetEdgeLengthF(max_scene_dim);

            set_target_edge_length(scene_length);
        }
Example #7
0
        public override void postprocess_target_objects()
        {
            AxisAlignedBox3d bounds = SceneMeshes[0].CachedBounds;

            for (int k = 1; k < InputSOs.Count; ++k)
            {
                bounds.Contain(SceneMeshes[k].CachedBounds);
            }
            MaxDimension = bounds.MaxDim;

            double cell_size = ToolDefaults.DefaultVoxelSceneSizeF(new AxisAlignedBox3d(MaxDimension, MaxDimension, MaxDimension));;

            set_grid_cell_size(cell_size);
            set_mesh_cell_size(cell_size);
            set_min_comp_size(2.0);
        }
Example #8
0
        public override void postprocess_target_objects()
        {
            foreach (var target in TargetObjects)
            {
                MaxVertexCount   = Math.Max(MaxVertexCount, target.SO.Mesh.VertexCount);
                MaxTriangleCount = Math.Max(MaxTriangleCount, target.SO.Mesh.TriangleCount);
            }
            foreach (var op in Operators)
            {
                op.VertexCount   = MaxVertexCount / 2;
                op.TriangleCount = MaxTriangleCount / 2;
            }

            double max_scene_dim = 0;

            foreach (var target in TargetObjects)
            {
                max_scene_dim = Math.Max(max_scene_dim, target.SO.Mesh.CachedBounds.MaxDim / target.sceneToObjUnitScale);
            }
            double scene_length = 3 * ToolDefaults.DefaultTargetEdgeLengthF(max_scene_dim);

            set_min_edge_length(scene_length);
        }