1
0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00

Compare commits

...

197 Commits

Author SHA1 Message Date
vpa
9e5394288d 0026870: Visualization - deactivated selections are not updated after object's re-computation
- update status in SelectMgr_SelectionManager::RecomputeSelection:
  1) is set to full for all selections;
  2) is switched to none only if selection was actually recomputed;
- test case for issue #26870
2015-11-16 16:42:58 +03:00
ski
3b5f0ca372 Small correction of qt samples 2015-09-28 16:04:44 +03:00
gka
6c672f4cd0 0026723: Qt IE sample can not import STEP and IGES files with names containing not ascii symbols
Added conversion of the names of the imported files in the  Utf8 coding
2015-09-25 16:47:56 +03:00
isk
1384cb64c9 Fix samples crash. 2015-09-25 14:16:24 +03:00
bugmaster
d222f955df Changing OCCT version from 6.9.1 beta to 6.9.1 2015-09-24 15:08:19 +03:00
ysn
56b5a03379 0026707: Remove references to "opencascade.org" in documentation
Links to OCC web sites in documentation are updated in accordance with the new site design.
2015-09-23 07:42:55 +03:00
nbv
1a060fcf21 0026632: HLR sample doesn't work with Algo mode
The main reason of the problem is Walking-line contains two equal Walking-points (the segment has null-length both in 3D and 2D).
2015-09-23 07:42:17 +03:00
isn
575e33ceba 0026701: BOPAlgo_Builder::Perform crash.
Data race eliminated (PCurves are stored in edges after paralleled calculation)

Add comments and make minor cosmetic changes.
2015-09-23 07:42:16 +03:00
anv
b9f21bee94 0026522: Exception while copying offset on C0 surface 2015-09-22 22:07:21 +03:00
abv
258faef5fc 0026671: Infinite loop in ShapeFix_Wire::FixSelfIntersection()
Avoid possible infinite loops in ShapeFix_Wire::FixSelfIntersection() -- when needed, fix is repeated once instead of going back in the loop
2015-09-22 22:07:20 +03:00
bugmaster
5add7c09fc Modification of service files for Voxel demo 2015-09-22 13:30:36 +03:00
aba
9ec3668b82 0026705: Visualization - OpenGl_Workspace aspect setters are not exported 2015-09-18 14:35:59 +03:00
bugmaster
05ff38f667 Update samples for VC++ 2013 2015-09-18 14:35:58 +03:00
oan
ee9749a81f 0026532: Meshing of edge with minSize parameter leads to incorrect result
Fix missed parameter.

Test case for issue CR26532
2015-09-18 14:35:57 +03:00
nbv
200a6865ad 0026687: SIGSEGV in BRepBuilderAPI_MakeFace
1. Check face location has been added.
2. Message, if mkplane command fails, has been added.
3. Test case for this issue has been created.

Changes in accordance with the remark.

Small correction of test case for issue CR26687
2015-09-18 14:35:35 +03:00
kgv
a86456de9a 0026688: Visualization, TKOpenGl - apply transparency within GLSL programs
OpenGl_ShaderManager::PushAspectFace(), setup alpha to Diffuse() component as in FFP.
OpenGl_ShaderManager::stdComputeLighting(), take alpha from material Diffuse component.
2015-09-17 16:35:44 +03:00
isk
b6c4618c0e 0026533: Draw command vdisplay requires vclear to update the presentation since OCC 6.9.0.
Update documentation related to vdisplay command and similar.
2015-09-17 16:32:40 +03:00
aml
74e9b952a4 0026196: Wrong result obtained by projection algorithm.
Improved periodicity handling when trimmed parameters became unclosed or nonperiodic, but underlying geometry closed or periodic.
Added possibility to not perform trim in GeomAdaptor::MakeSurface.

Minor corrections.

Test-case for issue #26196
2015-09-17 16:30:25 +03:00
agv
0d90638880 0026683: VRML 2.0: ImageTexture node not written 2015-09-17 14:33:23 +03:00
pkv
5bf1fb8dce 0026616: Memory leak in IntTools_Context::Hatcher
I. New features:
    No new features

II.2. class IntTools_Context
- method:
Geom2dHatch_Hatcher& IntTools_Context::Hatcher
  (const TopoDS_Face& aF)
- method:
IntTools_SurfaceRangeLocalizeData& IntTools_Context::SurfaceData
  (const TopoDS_Face& aF)

The memory allocation is provided using inner allocator of the object.

II. Modified entities:
packages:
IntTools
2015-09-17 14:33:22 +03:00
ibs
fd2f5a2535 0026691: CMake building procedure should support compiler of version 14.0 of Microsoft Visual C
"vc14" compiler name added to CMake building script
2015-09-17 14:25:37 +03:00
nbv
2fc40ae3de 0026642: ShapeUpgrade_UnifySameDomain introduces extremely high vertex tolerances
Algorithm of computation of safe shift value along 2D-line (in order to distance between two points was less than tolerance) has been improved.

Correction of some test cases in accordance with their new behavior.
2015-09-16 18:14:29 +03:00
ika
00ffff5c8c 0026419: [Regression?] Export of a reversed face leads to crash in 6.9.0 although proceeded in 6.8.0
Take basis surface from trimmed surfaces during IGES writing, because pcurves will be transformed, so trim will be shifted, accorded to new face bounds,
fix updating of seam edge,
change condition of using Segment during exporting periodic BSpline surfaces to IGES (if bounds are not in one period).

Test cases for issue CR26419
2015-09-16 10:48:32 +03:00
ika
086964d58a 0026573: IGES file with one entity 128 is not read
Add some workaround to read IGES files with lines, which lengths are less than standard 80.

Test case for issue CR26573

Correction of test cases for issue CR26573

Correction of test case for issue CR26573
2015-09-16 10:48:31 +03:00
ifv
fd87d80b23 0026651: IntTools_FClass2d gives incorrect result of classification 2015-09-16 10:48:30 +03:00
ifv
9189dced18 0026588: SIGSEGV in BRepFeat_MakeDPrism::Perform()
Incorrect piece of code is removed (not used)
2015-09-16 10:48:29 +03:00
abv
c16859d7b6 0024097: BRepAlgoAPI_Section returns wrong result
Test case added: bugs modalg_6 bug24097
2015-09-16 10:48:28 +03:00
nbv
2e6bcdaf8e 0026099: Wrong result done by 2d intersection algorithm
Detection of intersection for almost parallel lines has been improved.
2015-09-16 10:48:27 +03:00
pkv
5d3ec53550 0026567: Exception in Boolean intersection command
Correcting the usage of NCollection_IncAllocator
2015-09-16 10:48:26 +03:00
apv
55b22036f8 Adjusting test cases for current state of OCCT 2015-09-16 10:48:25 +03:00
gka
0b2fbc70d3 0025553: ShapeFix_Face::FixMissingSeam() fails to correct a face
Modification to support case when edges on face  have incorrect orientation was added.
Modification to support case when wires have intersecting segment was added

Test cases for issue 25553 added; other affected tests corrected (improvements)

Corrected test case
2015-09-16 10:47:51 +03:00
mkv
104c1cf105 0026575: Normal projection of an edge to a face is wrong 2015-09-11 19:06:20 +03:00
isk
898c424b6b 0026628: Button Erase (Delete where erase algorythm is used) works incorrect
Update AIS_InteractiveContext::EraseSelected() method.

Fix HLR sample

Fix samples.
2015-09-11 19:04:58 +03:00
isk
46b15b8275 0026153: Draw Harness, ViewerTest - "verase" does not remove selection highlight for shaded object 2015-09-11 19:04:14 +03:00
kgv
a4eb991a8e 0026665: Visualization, TKOpenGl - specify precision for integer uniforms explicitly within OpenGL ES
Use lowp for enumerations / Boolean uniforms.
Define default integer precision to highp in Fragment Shader when available.
2015-09-11 19:00:41 +03:00
kgv
f2f478782f 0026672: Visualization, TKOpenGl - workaround mobile hardware with extremely low precision of mod() in GLSL 2015-09-11 18:59:43 +03:00
mkv
98926f98db 0026638: Help of vcaps Draw command mentions wrong argument 2015-09-11 18:57:55 +03:00
jgv
68dace5e56 0026636: BRepOffsetAPI_ThruSections algorithm crashes on two inconsistent wires
Test case for issue CR26636
2015-09-11 18:56:07 +03:00
nbv
f81b508020 0026313: Method BRepBuilderAPI_GTransform::ModifiedShape(...) thows exception
Test cases for issue CR26313
2015-09-11 18:33:03 +03:00
jgv
46480f36ed 0026173: Wrong result of ChFi3d_ChBuilder algorithm: incorrect processing of G1 junctions at vertex
Test case for issue CR26173
2015-09-11 18:25:42 +03:00
kgv
a8dabcc5f7 0026650: Coding rules - fix misprint in NCollection_Vec3::operator/() 2015-09-11 18:11:54 +03:00
msv
dbde431489 0026635: UnifySameDomain loses internal edges
Treat internal edges in proper way to save them in the result.

The test "bugs heal bug26489_4" has been modified to reflect the actual behavior.

Test-case for issue #26635
2015-09-11 18:05:07 +03:00
isn
5b755bca16 0026498: BRepOffsetAPI_MakeOffset causes segmentation fault
Test case for issue CR26498
2015-09-11 17:51:02 +03:00
abv
1925eae948 0026627: [Regression] Shape Healing hangs as of OCC 6.8.0
Check for orientation of the solid corrected to ensure that cycle always finishes.

Test case added: bugs modalg_6 bug26627
Tests boolean volumemaker A3, B5, B7 corrected (improvements)
2015-09-11 17:30:30 +03:00
abv
61b0059a45 0026647: BRepTools::UVBounds() computes zero range by V
Calculation of bounding box on conic 2d curves corrected to work properly if specified parametric range is in negative values.

Test case added
2015-09-11 17:29:26 +03:00
pkv
4c15f1799b 0026582: Wrong result obtained by Common operator
class BOPAlgo_WireSplitter
   - static function:
Standard_Real Angle2D (const TopoDS_Vertex& aV,
                         const TopoDS_Edge& anEdge,
                         const TopoDS_Face& myFace,
                         const GeomAdaptor_Surface& aGAS,
                         const Standard_Boolean bIsIN)
The treatment of circles has been chenged to prevent
the loss of accuracy due to small differences in large values.

Small correction of test case for issue CR26582

Test case for issue CR26582

Conflicts:
	src/BOPAlgo/BOPAlgo_WireSplitter_1.cxx
2015-09-11 15:22:55 +03:00
gka
ccf61b1b85 0026644: ShapeUpgrade_UnifySameDomain - strange behavior
Modification to keep connectivity for non--manifold shapes during operation ShapeUpgrade_UnifySameDomain
2015-09-11 15:21:41 +03:00
ski
f6749d511e 0026637: Save function works incorrect in OCAF mfc sample
Storage format was corrected.
2015-09-11 15:21:40 +03:00
vpa
d833925587 0026462: Visualization - selection does not adapt to line width change
- added interface for changing sensitivity of a particular selection through both local and interactive context;
- added corresponding methods for changing sensitivity to SelectMgr_SelectionManager, SelectMgr_Selection and SelectBasics_SensitiveEntity;
- option -setSensitivity was implemented in vaspects Draw command;
- test case for issue #26462
2015-09-11 15:21:39 +03:00
vpa
81c75bf30d 0026195: Visualization - optimize selection algorithms
- initial transformation of triangulation is now applied to selecting frustum;
- switched from NCollection_Vec3 to gp collections to avoid conversions and usage of macros;
- calculation of frustum was refactored to reduce its build time;
- double pixel tolerances for selection were replaced by integer ones;
- switched to splitting along the main axis only in SelectMgr BVH selection primitive sets.
2015-09-11 15:21:38 +03:00
ika
c3a1713672 0026451: Crash importing STeP file
Add check for NULL.

Test case for issue CR26451
2015-09-03 18:00:45 +03:00
aml
a99ae14b48 0026075: Make Extrema_GenExtCC return IsParallel flag in case of parallel curves
1) Added check for parallel curves.
2) Changed unefficient o(n^2) duplicates deleting algorithm to o(n) algorithm.
3) Deleted useless upper level duplicates deleting algorithm.

Test-case for issue #26075
2015-09-03 01:56:53 +03:00
nbv
32b95ded37 0026251: Section curve cannot be found
Current algorithm ignores found triangles intersection (IntPolyh_PMaillageAffinage) and, consequently, cannot find start point for intersection line. Branch fixes this problem.

Test case for issue CR26251
2015-09-03 01:56:22 +03:00
abv
af6b493fc9 Change version from "6.9.1.dev" to "6.9.1.beta" 2015-09-02 14:39:58 +03:00
abv
409de561cd 0026245: Unable to write SAT file by default
XSAlgo_AlgoContainer is corrected to return original shape if Shape Processing fails.
Handling of situation of absence of defined operator sequence is corrected to apply DirectFaces operator by default on writing, regardless of target format.
ShapeProcess is corrected to output warning if operator sequence is not defined in resource file, and to continue if one operator in sequence has failed.
Message names are made more meaningful.
2015-09-02 14:39:57 +03:00
emv
f435c40bc8 0026019: Unstable behavior of test cases with operation mkvolume
The maps have been replaced with indexed maps to provide stability
of the algorithms based on the General Fuse algorithm.
2015-09-02 14:39:56 +03:00
kgv
0b94a4f33d 0026611: Visualization, TKService - fix NULL-dereference in Font_FontMgr on broken font
Check FT_Face::family_name for NULL during detection.
Skip fonts without mandatory UNICODE charset in Font_FontMgr.
2015-09-02 14:39:54 +03:00
kgv
4ce07e4ec6 0026613: Coding - avoid use of macros in Resource_Manager.cxx
Replace macros by enum Resource_KindOfLine.
2015-09-02 14:39:53 +03:00
nbv
23ea021260 0026310: Very slow boolean cut operations on cylinders
1. JoinWLines algorithm has been improved.
2. Reference to the V-boundaries is deleted when computing step.
3. Decreasing the tolerance when computing parameters of WLine.
4. Adding boundary point is forbidden if it lies in prolongation of found ones.
5. Possible reason of exception has been eliminated.
6. Processing of critical point has been improved.

Test cases for this issue have been created.
Correction of some test case(s).

Test case bugs/modalg_6/bug26310_4 is added

Update of test-cases for issue #26310
2015-09-02 14:39:52 +03:00
ika
d18c866246 0026241: Sewing algorithm computes tolerance of joint vertex too rough
Upgrade method of computing vertex tolerance.
Update function, which used the old method.
Test case for issue CR26241
Delete obsolete variables.
2015-09-02 14:39:51 +03:00
abv
f206b65145 Revert previously made adjustment of test cases for Linux
- boolean volumemaker C1: the problems disappeared on Windows are still present on Linux
- boolean volumemaker F8: improvement on Linux found on master due to #24682 does not happen in OCCT 6.9.1, since #24682 is not included
2015-09-02 14:39:50 +03:00
aml
da871fb5c9 0026605: Possible array out of bounds read in Extrema_GExtPC.gxx
Degenerated case fixed.
2015-09-02 14:39:49 +03:00
gka
1c9e5ae0f1 0026376: Imported STEP shape is partially wrong
Modification of the translation of the face based on the toroidal surface with negative major radius was made.
Seems that such face is considered by "Solid Works" and "ProE wildfire 5.0" systems as face having reversed orientation.
This step file was written by "Solid Works 2014".
2015-09-02 14:39:30 +03:00
ika
e84806af3b 0026461: STEP Import interface crashes
Add a check for NULL;
some code refactoring.
2015-09-02 14:39:29 +03:00
Roman Lygin
4ae88e723d 0026574: Remove redundant dependence of TKIGES on TKOffset 2015-09-02 14:39:27 +03:00
abv
134735be7b Adjustment of test cases
- bugs modalg_6 bug26238: check real values with tolerance to avoid false failures due to numeric deviations
- draft angle G8: removed TODOs that do not exhibit in 6.9.1 branch
- boolean gdml_private O1: unstable
2015-09-02 14:39:26 +03:00
aml
b01be5abf8 0026440: Invalid shape as a result of solid construction in BRepOffset_MakeOffset
Fixed degeneration in wall building in thicksolid mode.
2015-09-02 14:39:25 +03:00
aml
574ea6faba 0026556: Infinite calculations of BRepOffset_MakeOffset
Method for pre-analysis of input data added (CheckInputData).
Now it is possible to work with Error() function, which return error code.

Tests corrected according to changed error appearance.
2015-09-02 14:39:24 +03:00
azv
a2361eda86 0026458: BRepBuilderAPI_Copy does not copy mesh structure
The possibility to preserve triangulation in the copied shape is implemented.
It may be enabled by copyMesh flag, by default it is disabled.
Depending on copyGeom flag, the triangulation is shared with original shape (if False) or copied (if True).

Poly_Triangulation::Copy() method is added.
2015-09-02 14:39:23 +03:00
apn
d0af00dc66 0026447: Performance degradation intersecting cylindrical surfaces
Added test case bugs/modalg_6/bug26447
2015-09-02 14:39:22 +03:00
aml
e965d0c73c 0025981: Wrong result obtained by projection algorithm.
Adjust periodic added.

processing of V parameter periodicity added.

Test case for issue CR25981
2015-09-02 14:39:21 +03:00
nbv
17e64c3080 0025820: No Intersection Curves between surface of revolution and planes
Thin shapes processing has been improved.

Test-cases for issue #25820

Comment has been changed
2015-09-02 14:39:20 +03:00
mkv
fec4763816 Add test case for #26446 2015-09-02 14:39:19 +03:00
gka
3884c1d394 0026289: STEP import/export produces an empty shape
Exception is raised during reading step file containing p-curve having not-unique last knot.
Modification correcting misprint during computation new numbers of poles for such case was made in the file StepToGeom_MakeBSplineCurve.pxx
Protection against exception was made in the file StepToTopoDS/StepToTopoDS_TranslateEdge.cxx.
Warning message was added in the file StepToTopoDS_TranslateEdgeLoop.cxx.

Test case for issue CR26289
2015-09-02 14:39:18 +03:00
dbv
52ee6a456b 0026553: Out of range exception in BRepFill_Pipe::FindEdge
Test case for issue CR26553
Warning fix
2015-09-02 14:39:17 +03:00
jgv
1c6adc4f1e 0026554: Error in IntPatch_PrmPrmIntersection: initial step for walking line is not related with actual tolerance
Test case for issue CR26554
Small corrections for issue CR26554
2015-09-02 14:39:15 +03:00
abv
e297ccbaa1 0025775: "Default Gradient Backgound" in V3d_Viewer has no effect in new created V3d_View.
Complete the fix: add gradient background in second variant of V3d_View::SetWindow()
2015-09-02 14:39:14 +03:00
abv
e09a591f48 Adjustment of tests for OCCT 6.9.1:
- de iges_1 L8,P7 - corrected according to changes made in #24682, with minor amendment of number of labels
- heal wire_tails_real A5 - corrected as in master
- offset wire_unclosed_outside_0_025 B4 - correcting according to actual state (looks better)
- de step_3 F1 - corrected according to actual state, see #26597
- de iges_1 N9 - reverted to state before integration of #25593 (zero-area face is created due to self-intersecting wire)
2015-09-02 14:39:13 +03:00
abv
cc19ba1caf Adjusting testing case 2015-09-02 14:39:12 +03:00
abv
11fd45038f 0026403: Lack of Standard_EXPORT keyword in SelectMgr headers
Some Standard_EXPORT keywords added to be able to link with TKV3d
2015-09-02 14:39:11 +03:00
kgv
41d16f029b 0026547: Configuration - fix compilation errors on VS2015
Interface_STAT.cxx - rename local variable 'stat' to 'myStat' to avoid name collision.
OSD_FileNode.cxx - pass correct argument to va_start().
STEPConstruct_AP203Context::DefaultDateAndTime() - use _get_timezone() instead of global variable timezone on msvc.
Graphic3d_ArrayOfPrimitives::VertexColor() - fix reinterpret_cast() argument.

Small correction: OCC26481-linesarc.brep is equal to bug26296_linesarc.brep
2015-09-02 14:39:10 +03:00
jgv
8b04c979b2 0026540: Errors in BRepOffsetAPI_MakeOffset: infinite loop in method FixHoles for closed results.
Test case for issue CR26540
2015-09-02 14:39:09 +03:00
ysn
7c2cc7228d Sign added and some formatting changes 2015-09-02 14:39:08 +03:00
pkv
eb20feb3bc 0026243: Boolean operations failed on shapes with fillets
Detected bugs have been fixed.

Test case for issue CR26243
2015-09-02 14:38:50 +03:00
mkv
dd531ee973 0026442: Access violation in BRepOffset_MakeOffset
Test cases for issue CR26442
2015-09-02 14:38:49 +03:00
apv
ec356f5273 0024522: Application crashes on view closing in case of using of clipping planes
Test-case for issue #24522
2015-09-02 14:38:48 +03:00
vpa
1ba2234442 0026249: Visualization, TKV3d - fix possible division by zero in SelectMgr_RectangularFrustum
Added zero-length check for triangle normal in SelectMgr_RectangularFrustum::Overlaps
2015-09-02 14:38:47 +03:00
oan
08c65c2355 0026485: Problem with the normals of a triangulated shape
Use gp::Resolution() instead of Precision::SquareConfustion() in order to normalize normal vectors according to implementation of gp_Vec::Normalize().

Test case

Test-case for issue #26485
2015-09-02 14:38:46 +03:00
apv
86fc2729b8 0026496: Error in use the BRepCheck_Analyzer
Test-case for issue #26496
2015-09-02 14:38:45 +03:00
abelcsik
73bc951212 0026385: Fix to prevent BRepMesh from possible crash due to pointer to local variable stored inside Extrema_LocateExtPC
Made the BRepAdaptor_Curve a member of BRepMesh_EdgeParameterProvider to ensure that it is created before and destroyed after the Extrema_LocateExtPC that uses it.
2015-09-02 14:38:43 +03:00
aml
5d59062054 026464: BRepOffset_MakeOffset does not provide valid output
Handling of degenerated case improved.

Test-case for issue #26464
2015-09-02 14:38:42 +03:00
jgv
c93109fe43 0026481: Incorrect result of BRepOffsetAPI_MakeOffset: excess hanging arcs in the open result with join type GeomAbs_Arc
Test-case for issue #26481
2015-09-02 14:38:41 +03:00
pkv
1ecda52ad7 0026483: Option Run Parallel is not used by the command bopargcheck
I. New features:
No new features

II. Changes:
II.1 class BOPTest
-static function:
Standard_Integer bopargcheck (Draw_Interpretor& di,
                              Standard_Integer n,
                              const char** a )
The option has been retrieved and passed to the checker algorithm.

III. Modified entities:
packages:
BOPTest
2015-09-02 14:38:40 +03:00
nbv
c19a07bc44 0026484: BRepExtrema_DistShapeShape hangs
Check in math_GlobOptMin::computeGlobalExtremum(...) method if the parameter went out of boundary(-ies).

Added test case bugs/modalg_6/bug26484
2015-09-02 14:38:39 +03:00
aml
a2e99c91fa 0026473: Offset API fails to create offset shape
Tolerance of map building changed.
Added possibility to work 0.0 offset value.

Added test cases bugs/modalg_6/bug26473_1 bug26473_2
2015-09-02 14:38:38 +03:00
emv
f85265c252 0026420: BOPAlgo_Builder resets "Closed" flag in the result
Set flag Closed to new Wires and Shells created in General Fuse algorithm if necessary.

Test-cases for issue #26420
2015-09-02 14:38:37 +03:00
emv
9926d83075 0026444: Boolean operation "bcut" gives invalid result between solid and halfspace solid.
class BOPAlgo_PaveFiller
method void BOPAlgo_PaveFiller::PutPaveOnCurve
  (const Standard_Integer nV,
   const Standard_Real aTolR3D,
   BOPDS_Curve& aNC,
   const BOPCol_MapOfInteger& aMI,
   BOPCol_DataMapOfIntegerReal& aMVTol,
   const Standard_Integer iCheckExtend)

Do not put the pave on the curve in case if there is already one with the same parameter.
Update tolerance of the existing vertex to reach the new one.

Added test case bugs/modalg_6/bug26444.
Test boolean/volumemaker/G1 is stable now (deleted TODOs), test offset/faces_type_i/C9 is bad (offset is done with wrong result).
2015-09-02 14:38:36 +03:00
duv
9b22664c02 0026492: OpenGl_FrameBuffer does not releases itself correctly
Logic related to myIsOwnBuffer flag in OpenGl_FrameBuffer was corrected.
2015-09-02 14:38:35 +03:00
kgv
e646e2af68 0026476: Visualization, TKOpenGl - do not enable GL_NORMALIZE in core profile 2015-09-02 14:38:34 +03:00
kgv
c57360a7ce 0026479: Visualization, TKOpenGl - do not implicitly turn off stereo in OpenGl_Workspace::RedrawImmediate() 2015-09-02 14:38:32 +03:00
apl
d3fab23ba9 0025775: "Default Gradient Background" in V3d_Viewer has no effect in new created V3d_View. 2015-09-02 14:38:31 +03:00
vpa
c6a60baab7 0026430: Visualization - segmentation fault in opened local context
- check for empty dataset in Select3D_SensitiveSet was added;
- test case for issue #26430
2015-09-02 14:38:30 +03:00
apl
c633105394 0026401: Visualization - small boxes in front of big one disappear in perspective view 2015-09-02 14:38:29 +03:00
isn
9780f0e177 0026466: UnifySameDomain creates invalid result shape from valid input shape
Test-case for issue #26466
2015-09-02 14:38:28 +03:00
emv
58c3e0dcd4 0026393: Add draw commands to evaluate history of modifications of BOP
DRAW commands bmodified, bisdeleted, bgenerated have been implemented to track
the history of shapes modifications in Boolean and General Fuse operations.

Test-case for issue #26393
2015-09-02 14:38:27 +03:00
aml
6063352953 0026468: Out of range exception on current master
Problem with different ranges fixed.

test cases update.
2015-09-02 14:38:26 +03:00
kgv
271eca4e51 0026454: Visualization, TKOpenGl - do not require deprecated function of GL_ARB_vertex_type_2_10_10_10_rev in core profile 2015-09-02 14:38:25 +03:00
aml
06fe939893 0026446: GeomConvert::ConcatC1 produces not expected curve
Concatenation fixed.
2015-09-02 14:38:24 +03:00
aml
f6ec43465e 0026418: Unjustified limitation on tolerance of a input shape in BRepOffset_MakeOffset
Performance improvements and regression elimination.
Handling of degenerated case added.

Update of test-case offset faces_type_a A2 according to the new behavior
Test-case for issue #26418
2015-09-02 14:38:22 +03:00
gka
24bda0a60b 0026408: Exception during fixshape procedure.
Attached invalid shape is represented by solid containing one face twice.
Protection from such case was added in ShapeFix_Shell class.
Creation of COMPSOLID was modified for case when shells composing COMPSOLID have the same shared faces in order to prevent hanging.
Small modification.Protection to avoid exception
Test-case for issue #26408
2015-09-02 14:38:21 +03:00
kgv
1a8e73d756 0026424: Visualization, TKOpenGl - fix text rendering in core profile
OpenGl_Context::init() - fix condition on initializing alien OpenGL context within core profile.
OpenGl_Font::renderGlyph() - use GL_RED data format in core profile.
OpenGl_Text::render() - do not use GL_ALPHA_TEST in core profile.

Test-case for issue #26424
2015-09-02 14:38:20 +03:00
aml
a010375290 0026351: Wrong result found by the projection algorithm
C2 continuity intervals changed to Knots intervals in case of Bspline curve.
Fixed incorrect extremaPC usage.

Test case for issue CR26351
Update of test-cases according to the new behavior

Conflicts:
	tests/de/step_2/U8
2015-09-02 14:38:19 +03:00
nbv
efe826bff1 0026308: Segmentation fault in BSplCLib::LocateParameter
Detection of "jumping" knot value has been improved.
Test-case for issue #26308
Comment has been added in test case bugs/modalg_6/bug26308.
2015-09-02 14:38:18 +03:00
ifv
534beb0a8d 0026406: BRepPrimAPI_MakeRevol crash when rotating Paraboloid face.
Test-case for issue #26406
2015-09-02 14:38:17 +03:00
ifv
bc479df6c7 0026387: BRepPrimAPI_MakePrism crash when extruding Paraboloid face.
Test-cases for issue #26387
2015-09-02 14:38:16 +03:00
ifv
233b69d788 0025048: Wrong return value of GeomLib_Tool::Parameter 2015-09-02 14:38:15 +03:00
oan
2c74997d54 0026398: Tricheck command should be extended to show free nodes and links breaking mesh consistency
Remark from MSV
2015-09-02 14:38:13 +03:00
apl
91378854c3 0026369: Modeling Data - Geom_OffsetSurface direction is wrong for indirect conical surface 2015-09-02 14:38:12 +03:00
vpa
704116ecb1 0026394: Visualization - eliminate unused variable in SelectMgr_RectangularFrustum
Unnecessary calculations were removed
2015-09-02 14:38:11 +03:00
oan
76b8e79250 0026390: IntTools_Context should provide possibility to set tolerance used by PointOnSurf projector instead using of strict value 1.e-12
New method SetPOnSProjectionTolerance to set projection tolerance has been added IntTools_Context. By default it is set to 1.e-12
2015-09-02 14:38:10 +03:00
emv
d0da782fe1 0026379: Wrong result produced by the volume maker algorithm
1. class BOPAlgo_ShellSplitter
static method void RefineShell(TopoDS_Shell& theShell,
                               BOPCol_ListOfShape& aLShX)
Added protection from INTERNAL edges.

2. class BOPAlgo_MakerVolume
method void BOPAlgo_MakerVolume::MakeBox(BOPCol_MapOfShape& theBoxFaces)
Creation of the overlapping box of proper size.

Test-cases for issue #26379
2015-09-02 14:38:09 +03:00
aml
067a4a33d8 0026356: Wrong result done by projection algorithm
Changed internal one dimension search algorithm in case of fast changing curve.

Test-case for issue #26356
2015-09-02 14:38:08 +03:00
nbv
9af6ab1e5c 0025613: Wrong distance found by xdistef command for attached shapes
1. Divide B-spline curve on sub-intervals (bounded by knots values).
2. Class BRepLib_CheckCurveOnSurface_TargetFunc has been optimized for future implementation to checkshape algorithm (Adaptors are used instead of Geom_Curve(Surface)).
3. Parallelization of new algorithm.

The algorithm is based on math_PSO class.

Test cases for issue 25613 have been created.

Changes in accordance with the last remarks
2015-09-02 14:38:07 +03:00
abv
f6c4ac4b8d 0026341: Uninitialized field in ShapeFix_Face
Parameter RemoveSmallAreaFaceMode in ShapeFix_Face is properly initialized; some other minor corrections
2015-09-02 14:38:06 +03:00
ink
838a9fca4b 0026342: No materials are read from STEP
Changed number of  arguments for descriptive_representation_item (for the case when description is absent).

Test case for issue CR26342
2015-09-02 14:38:05 +03:00
aml
a1b71d7f53 0026339: [Regression in 6.9.0] Projecting a curve hangs
Changed computation of point projection to more correct.
Calculation periodicity information added to cache.
Test case for issue CR26339

Small correction of test case for issue CR26339
2015-09-02 14:38:04 +03:00
jgv
f9b5dde31f 0026332: BRepOffsetAPI_ThruSections algorithm fails on two wires with different number of edges
Correction according to remark.

Correction of mistake.

Test case for issue CR26332
2015-09-02 14:38:02 +03:00
jgv
de2f4c61bf 0026296: Errors in BRepOffsetAPI_MakeOffset: failure because of wrong direction of bisector.
Test cases for issue CR26296

Fix of regressions.

Small correction of test cases for issue CR26296
2015-09-02 14:38:01 +03:00
mkv
f2d0720f0e Eliminating instability in test cases 2015-09-02 14:38:00 +03:00
isk
e5e388ac07 0023028: Visualization, TKOpenGl - eliminate global static variables
OpenGl_CappingAlgo - move global variables to OpenGl_Workspace class fields.
OpenGl_View::ShaderSource::Source() - drop static for local variable.
OpenGl_Window - drop redundant global constant THE_DEFAULT_BG_COLOR.
2015-09-02 14:37:59 +03:00
isn
4a934783ee 0026219: ShapeUpgrade_UnifySameDomain fails with StdFail_NotDone exception
Avoid merging edges if the collapsed vertex has a third connected edge.
Fix the problem when merged edges have different location.
Test case for issue CR26219

Additional fix to improve robustness.

Test cases for issue CR26219

Small correction of test cases for issue CR26219
2015-09-02 14:37:58 +03:00
ifv
e55cd82c8e 0026330: BRepOffsetAPI_ThruSections creates invalid shape
Test case for issue CR26330
2015-09-02 14:37:57 +03:00
apl
9f87ad8c86 0026357: Visualization - Panning zooms view if aspect ratio > 1 2015-09-02 14:37:56 +03:00
emv
cf4520ebc6 0026316: Infinite modification of the shapes in General Fuse operation
Check the validity of the intersection point between Faces.

Test case for issue CR26316

Correction of the test case for the issue.

Small correction of test case for issue CR26316
2015-09-02 14:37:55 +03:00
kgv
039add17a8 0026359: Revolution shape of Parabola Curve has no triangles
Adaptor3d_IsoCurve::Circle() - prevent parallel check with NULL-vector

Test case for issue CR26359
2015-09-02 14:37:54 +03:00
kgv
c1f20b28fe 0025556: Visualization - support stereo pair formats recognized by consumer display devices
Graphic3d_StereoMode - add new enumeration for stereoscopic outputs:
- Graphic3d_StereoMode_QuadBuffer
- Graphic3d_StereoMode_Anaglyph
- Graphic3d_StereoMode_RowInterlaced
- Graphic3d_StereoMode_ColumnInterlaced
- Graphic3d_StereoMode_ChessBoard
- Graphic3d_StereoMode_SideBySide
- Graphic3d_StereoMode_OverUnder

Graphic3d_RenderingParams - add new options controlling stereo output:
- StereoMode
- ToReverseStereo
- AnaglyphFilter

OpenGl_ShaderManager - add predefined GLSL programs for new stereo outputs.
OpenGl_Workspace::Redraw() - do not implicitly disable stereo to allow stereo dump as is.
OpenGl_Caps - add flag swapInterval to control VSync.
OpenGl_Workspace::BufferDump() - handle cases with non-applicable GL_PACK_ROW_LENGTH.

CALL_DEF_WINDOW - drop unused fields; add fields "left" and "top"
to reverse stereo pair for interlaced output depending on window position.

Draw Harness, ViewerTest:
- Extend syntax of command vstereo to setup stereo.
- Extend vdump command to allow dump of stereoscopic pair in different formats.
- Extend command vcaps with option vsync.
- Use mouse scroll to zoom and adjust ZFocus in WinAPI.
- Use "/" and "*" to adjust IOD.

v3d/glsl/stereo - add test case for stereo modes.

Cocoa_LocalPool, OSD_EnvironmentIterator - fix compilation issues on OS X Snow Leopard.
2015-09-02 14:37:52 +03:00
apl
5fcc7382dc 0025760: Visualization - precision factor added to ZNear, ZFar in method ZFitAll() of Graphic3d_Camera is not enough
Small correction of test cases for issue CR25760
2015-09-02 14:37:12 +03:00
ifv
b44e3bbd33 0026305: BRepFeat_MakePrism returns inconsistent results && 026315: BRepFeat_MakeRevol fails to create revol from shape
Test-cases for issues #26305 and #26315
2015-09-02 14:32:40 +03:00
vpa
bd7987d5dd 0026324: Visualization - fix iteration through corrupted memory in AIS_LocalContext::FindSelectedOwnerFromShape
The signature of SelectMgr_ViewerSelector::ActiveOwners is changed to return output parameter to avoid crash
2015-09-02 14:32:38 +03:00
nbv
06ce88fdef 0026151: Wrong result obtained by intersection algorithm.
1. Methods IntPolyh_MaillageAffinage::GetMinDeflection() and IntPolyh_MaillageAffinage::GetMaxDeflection() have been created (see cdl-file for more detail information).
2. Extended check, if starting point of WLine is a tangent point, has been implemented in IntWalk_PWalking::Perform(...) method.

Test cases for issue CR26151
2015-08-23 23:23:32 +03:00
abv
168bef440d 0026306: Access to deleted object in ShapeFix_FixSmallSolid
Code corrected to avoid accessing element of sequence by reference after it is removed.
2015-08-23 23:23:32 +03:00
abv
7e66f8d719 0026307: Minor improvements in snowflake sample
- background is set to while, and lines are black
- dimension line added
- category is corrected
2015-08-23 23:23:31 +03:00
vpa
954e19f009 0026284: Visualization - eliminate recursion in SelectMgr_SelectionManager
Small correction of test case for issue CR26284
2015-08-23 23:23:30 +03:00
msv
587c15bd7d 0026206: BRepClass_FaceClassifier returns TopAbs_OUT for internal point
Classifier has been corrected to not take into account a probing point if the probing line appears to be tangent to the boundary at this point.

But allow to use tangent point if all points on the edge are tangent.
Modify bad test cases.

Test case for issue CR26206
2015-08-23 23:23:29 +03:00
vpa
026dbb46c9 0026304: Visualization - wrong calculation of point in SelectMgr_RectangularFrustum::DetectedPoint 2015-08-23 23:23:28 +03:00
ifv
5050c82886 0026230: Segmentation fault because a NULL curve is used without precaution in case of a projection failure 2015-08-23 23:23:27 +03:00
nbv
3e673cffa9 0026193: Incomplete intersection curve
1. Conditions for adjusting and for breaking Walking-lines have been amended.
2. Processing of case when WLine should be broken has been changed.

Test cases for issues 26193 and 26208 have been added

Cosmetic correction of test-cases

Modification of test-case according to the new behavior.
2015-08-23 23:23:26 +03:00
nbv
ae5635ca15 0026281: BRepCheck_Edge::Tolerance() raises exception on the given shapes
The reason of the exception has been eliminated

Test-cases for issue #26281
2015-08-23 23:23:25 +03:00
ifv
edab390e05 0026233: BRepOffset_MakeOffset makes incorrect result
Test-case for issue #26233
2015-08-23 23:23:24 +03:00
omy
44d4c9e586 0026276: Visualization, TKOpenGl - add missing Standard_EXPORT to matrix management methods in OpenGl_Context
These methods are useful for applying matrices transformations.
2015-08-23 23:23:23 +03:00
omy
4b2089edec 0026275: Visualization, TKOpenGl - add public constructor for OpenGl_ShaderProgram 2015-08-23 23:23:23 +03:00
bugmaster
de7efa01cc Temporally removing several cases from boolean/gdml_private group. 2015-08-23 23:23:22 +03:00
mkv
ff70447591 Update testing cases after integration issue 26253 2015-08-23 23:23:21 +03:00
jgv
6658b677bc 0026185: BRepOffsetAPI_MakeOffset: regressions on some customer's cases
Minor correction.

Test-cases for issue #26185

Modifications in test-cases according to developer's notes
2015-08-23 23:23:20 +03:00
pkv
5719c9ecc4 0026253: Wrong result obtained by General Fuse operator.
Replace BOPCol_MapOfShape by BOPCol_IndexedMapOfShape to provide
the same order of shells in the result

Test case for issue CR26253

Correction of test case for issue CR26253
2015-08-23 23:23:19 +03:00
abk
6670aadd5d 0026261: Create a tool to remove tails from any wire
A tool to remove tails from the wires of a shape was created.
The tool is based on mechanism 'ShapeFix',
is located in types 'ShapeFix_Wire' and 'ShapeAnalysis_Wire',
is enabled through method 'ShapeFix_Wire::FixTailMode' and
is initialized by methods 'ShapeFix_Wire::SetMaxTailAngle' and 'ShapeFix_Wire::SetMaxTailWidth' and
is called through method 'ShapeFix_Wire::FixTails'.
The status of any performing of the last method is accessible through method 'ShapeFix_Wire::StatusFixTails'.
The tail angle is checked only at the tail start.

Mechanism 'ShapeFix' was modified:
- the tool is disabled by default;
- algorithm 'Fix notched edges' is disabled then the tool is enabled;
- the tool and the last algorithm work in turns then the tool works on the request.

'Draw' command 'fixshape' was extended by options '-maxtaila' and '-maxtailw' to test the tool.

'Draw' tests to test the tool were created.

Algorithm 'fixshape' was changed in type 'ShapeProcess_OperLibrary' to
- use new parameters named 'FixTailMode', 'MaxTailAngle' (in degrees) and 'MaxTailWidth' from the algorithm context;
- apply the tool after the shape will be fully fixed if the tool was enabled.

Place holders for the new parameters were created in the resource file of mechsnism 'STEPControl_Reader'.

Test cases for issue CR26261
2015-08-23 23:23:18 +03:00
abk
84c9d28189 0026259: Extend commands '{l|s|v}props' to output the values with the full precision
Additional option '-full' was added to 'Draw' commands 'lprops', 'sprops' and 'vprops'
to output the values not only with the short but and with the full precision.
2015-08-23 23:23:17 +03:00
aml
b97a779a9f 0026022: Extrema_ExtCC gives not precise solution
Conditional optimization added to Newton optimization algorithm.
Test case for issue CR26022
2015-08-23 23:23:17 +03:00
dbp
b5913c3c89 0026221: Visualization - use NCollection_IndexedMap instead of NCollection_Sequence in OpenGl_Layer to improve performance 2015-08-23 23:23:16 +03:00
azv
5520ae9665 Extract of fixes from 0024682: Move out B-spline cache from curves and surfaces to dedicated classes BSplCLib_Cache and BSplSLib_Cache
4. Precised calculation of derivatives of surface of revolution is implemented for the points of surface placed on the axis of revolution (Geom_SurfaceOfRevolution.cxx)

5. Small modifications are made to adjust algorithms to new behavior of B-spline calculation.

6. Test cases were modified according to the modern behavior.

7. Changes in BRepLib_CheckCurveOnSurface to use adaptors instead of geometric entities

9. Added methods to access directly poles, knots, multiplicities of BSpline curves and surfaces
2015-08-23 23:21:30 +03:00
aml
f44d9449e4 0026063: GeomAPI_ExtremaCurveSurface have inexact API
Reason of exception was eliminated.

Test-case for issue #26063
2015-08-21 10:59:15 +03:00
pkv
b96d3ed29d 0026263: Inconsistent results of bopargcheck snd checkcurveonsurf commands.
Changes:
class BOPTest
- static function:
Standard_Integer checkcurveonsurf(Draw_Interpretor& di,
                                  Standard_Integer n,
                                  const char** a)
has been changed.
The condition that provides selection of faulty curves has been modified
to be coherent with the same condition in  class BOPAlgo_Analyzer.
2015-08-21 10:59:14 +03:00
abv
5b27fad6ce 0026262: mixing qvector.h and math_Memory.hxx won't compile
Files math_Memory.cxx and .hxx removed: function memmove() should be available on all modern platforms in standard C library
2015-08-21 10:59:13 +03:00
aml
9f1bb68f68 0026044: Optimize math_GlobOptMin class to enter options for solutions of some specified problems
Possibility to search single optimum added.
2015-08-21 10:59:12 +03:00
dbp
6c3dff3505 0026180: Modeling Algorithms - Provide shape self-intersection detector
Small correction of test case for issue CR26180

Fix GCC compilation warnings.
2015-08-21 10:59:11 +03:00
apn
114aa0dcf6 Added parameter highlight_percent in command testdiff.
It highlights considerable (>value in %) deviations of CPU and memory (default value is 5%).
2015-08-21 10:59:10 +03:00
apn
8b318a2ed9 0026237: Change platform in TODOs from Debian\Mandriva to Linux
Change platform in occt test cases in TODOs from Debian\Mandriva to Linux

Small corrections in test cases. Return procedure _tests_platform_def.
2015-08-21 10:59:09 +03:00
azn
1edc472052 0025923: Remove small wires on face read from STEP
The analysis of small area in the method ShapeAnalysis_Wire::CheckSmallArea is performed the following way:
- On the fisrt step algorithm produces a rough estimation of part of surface area.
- In a case if obtained estimation is less than tolerance then evaluate real area and comapre this value with tolerance.
- New flag has been added to XSTEPResource/IGES. In a case if flag is true the faces with small 3d area is removed from ShapeFix context.

Test-case for issue #25923 and update test-cases in de group according to the new behavior.
2015-08-21 10:59:08 +03:00
dbp
7197da1a33 0026220: Visualization - In Graphic3d_Structure use single NCollection_IndexedMap instead of NCollection_DataMap and NCollection_Sequence 2015-08-21 10:59:07 +03:00
dbp
b34ca16935 0026199: Visualization - use NCollection_IndexedMap instead of NCollection_Sequence in OpenGl_BVHClipPrimitiveSet to improve performance
This patch improves performance of OpenGl_BVHClipPrimitiveSet. In particular, on the attached test case for 90 000 spheres the results are the following:

1) Master: vdisplay - 55 sec, 5 FPS, 1.4 GB memory, vclear - 180 sec.
2) Branch: vdisplay - 1.3 sec, 5 FPS, 1.4 GB memory, vclear - 90 sec.

So, the patch improves vdisplay in ~40 times, and vclear in ~2 times without extra memory and with no impact on rendering performance. However, the vclear time is still significant. According to profile results, it is due to Graphic3d_Structure::DisconnectAll method.

Test case for issue CR26199

Fix invalid warnings in 'vdefaults' command.
2015-08-21 10:59:06 +03:00
vpa
c8dad3b06c 0026209: Visualization - provide a method to fit view to the specific bounding box
Methods V3d_View::FitAll and NIS_View::FitAll3d now take arbitrary bounding box as a parameter;
Option -selected added to vfit command to fit only selected entities in Draw;
F key press now fits selected objects if any by default.
2015-08-21 10:59:05 +03:00
apl
6d3066d9b8 0026082: When view is resized horizontally the visualization is not scaled 2015-08-21 10:59:04 +03:00
abv
f8fdf72ad2 0026232: Multithreaded crash in IntAna_Int3Pln::Perform due to statics
"Static" keyword removed from local variable declarations in IntAna_Int3Pln::Perform()
2015-08-21 10:59:03 +03:00
jgv
f0ab769c94 0026201: Wrong processing of dissymetric chamfer: order of chords unjustly changes
Test-case for issue #26201
2015-08-21 10:59:02 +03:00
apl
fd75a870c5 0026163: Visualization - AIS_Shape::SetWidth() should not overwrite the free boundary color 2015-08-21 10:59:01 +03:00
ski
0fcd05c599 0026226: Can't compile and run OCC mfs samples
Files ISession2D_SensitiveCurve.h and ISession2D_SensitiveCurve.cpp were removed from mfc Geometry sample.
Output directory for mfcsample project was changed from lib/libd to bin/bind.
2015-08-21 10:59:00 +03:00
nbv
15655a8ba3 0026197: Incomplete intersection curve
Correct the algorithm to get right Start point for extension of the walking line.

Test case for issue CR26197

Correction of test case bugs/modalg_6/bug26197
2015-08-21 10:58:59 +03:00
anv
bcd2ec1031 0025763: SSP sample is unable to build the proper surface on the given cloud of points
Some improvements to work with periodic splines
2015-08-21 10:58:58 +03:00
vpa
213046ff8a 0026217: Visualization, Select3D_SensitiveCircle - fix compilation with CLang for iOS
Inclusion detection for filled sensitive circles was corrected
2015-08-21 10:58:57 +03:00
pkv
ab1be48a6a 0026224: Wrong result obtained by Common operator.
Changes:
class BOPTools_AlgoTools2D
 - method:
Standard_Integer BOPTools_AlgoTools2D::AttachExistingPCurve
(const TopoDS_Edge& aE2,
const TopoDS_Edge& aE1,
const TopoDS_Face& aF,
const Handle(IntTools_Context)& aCtx)
has been changed.
The treatment of the curves that need to be reversed has been modified
taking into account reversed parameter

Test case for issue CR26224
2015-08-21 10:58:56 +03:00
emv
f00e46680f 0026218: Wrong result done by General Fuse algorithm
class BOPAlgo_PaveFiller
1. method
  void BOPAlgo_PaveFiller::MakeBlocks()
 Update of FaceInfo IN information before filling the maps.

2. methods
  void BOPAlgo_PaveFiller::UpdateFaceInfo
    (BOPDS_DataMapOfPaveBlockListOfPaveBlock& theDME,
     const BOPCol_DataMapOfIntegerInteger& theDMV)

  void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
    (const Standard_Integer theInt,
     const BOPDS_IndexedMapOfPaveBlock& aMPBOnIn,
     const BOPCol_DataMapOfIntegerListOfInteger& aDMBV,
     BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
     BOPCol_DataMapOfShapeInteger& aMVI,
     BOPDS_MapOfPaveBlock& aMPB)

  Small changes in treatment of existing pave blocks when making new ones from intersection curves.

Test case for issue CR26218

Correction of test case for issue CR26218
2015-08-21 10:58:55 +03:00
apn
295990967f Update of testing cases for Debian 7.0 64 bit 2015-08-21 10:58:54 +03:00
ibs
49c44da2ad 0025750: Coding rules - eliminate GCC warning -Wunused-but-set-variable in OSD_signal.cxx for Android build
Move variable aSigInfo to the proper scope.
2015-08-21 10:58:53 +03:00
apn
7f2a0207a7 0026192: Porting testing database on Debian70 64bit
Modified test cases for platform Debian70 64bit

Changed todo mapping for Debian70-64
2015-08-21 10:58:52 +03:00
jgv
813378a1a4 0026202: Wrong result of chamfer on cylindrical surface: wrong value of chord
Test case for issue CR26202
2015-08-21 10:58:51 +03:00
msv
24b4a814bf 0026198: ShapeConstruct_ProjectCurveOnSurface builds infinite line instead of bounded curve
Description of the method ShapeConstruct_ProjectCurveOnSurface::Perform has been updated to actual state.
2015-08-21 10:58:50 +03:00
vsr
00e18bf7e4 0026144: Missing operators in gp_GTrsf 2015-08-21 10:58:49 +03:00
pkv
a72c4cb0e7 0026469: Methods Seek(), ChangeSeek() are missing in class NCollection_IndexedDataMap
I. New features:
1.1. class NCollection_IndexedDataMap
 - method:
 const TheItemType* Seek(const TheKeyType& theKey1) const
 has been added.
 The method Seek returns pointer to Item by Key.
 Returns NULL if Key was not found.

 - method:
 TheItemType* ChangeSeek (const TheKeyType& theKey1)
 has been added.
 The method ChangeSeek returns modifiable pointer to Item by Key.
 Returns NULL if Key was not found.

II. Changes:
 No changes.

III. Modified entities:
 packages:
 NCollection
2015-08-21 10:58:48 +03:00
BenjaminBihler
06b2381dc9 0026423: Complete documentation of CPnts_AbscissaPoint Adv/Perform methods 2015-08-21 10:58:47 +03:00
kgv
0ccb5dcc03 0026453: NCollection_StlIterator - declare reference getters as const 2015-08-21 10:58:46 +03:00
abv
e5db9d8f50 0026448: Method Prepend() of sequence breaks it if argument is empty sequence
Check for empty input sequence added in methods Append() and Prepend() of TCollection and NCollection sequences.

Test bugs fclasses bug26448 added
2015-08-21 10:58:45 +03:00
anv
72d472e0c7 0026345: Shape Healer application crashes trying to run Shape Processing
Empty element, that was added to the Array, causes an exception while accessing myUserMap

LoadResourceManager is receives environment variable name, but stat is waiting for full path
2015-08-21 10:58:35 +03:00
abv
bd7a454d6c 0026273: Comments to methods are misplaced in gp_Vec.cdl
Location of comments corrected

Grammar fix
2015-08-21 10:58:34 +03:00
myn
83f70fe2b4 0026287: Bug in NCollection_AccAllocator::Free() sometimes causes crash in debug mode 2015-08-21 10:58:33 +03:00
isn
e32b64f095 0024994: missing implematation of constructor: BRepClass_FaceClassifier 2015-08-21 10:58:32 +03:00
dbp
bcbb5d9ba4 0026203: Foundation Classes - provide method ::Swap() for NCollection_IndexedMap and NCollection_IndexedDataMap to transpose map elements
Add new tests in group "perf ncollection".
2015-08-21 10:58:31 +03:00
vsr
cbb329c42c Increment OCCT version up to 6.9.1dev 2015-08-20 08:52:53 +03:00
884 changed files with 20264 additions and 8506 deletions

View File

@@ -63,6 +63,8 @@ macro (OCCT_MAKE_COMPILER_SHORT_NAME)
set (COMPILER vc11)
elseif (MSVC12)
set (COMPILER vc12)
elseif (MSVC14)
set (COMPILER vc14)
endif()
elseif (DEFINED CMAKE_COMPILER_IS_GNUCC)
set (COMPILER gcc)

View File

@@ -140,7 +140,8 @@ dev_guides/svn/svn.md
@section OCCT_DOC_SECTION_5 Additional Resources
More information about OCCT can be found at http://www.opencascade.org
More information about OCCT can be found at http://www.opencascade.com and http://dev.opencascade.org sites.
The information on formula syntax can be found at:
http://en.wikipedia.org/wiki/Help:Displaying_a_formula

View File

@@ -3,6 +3,11 @@
@tableofcontents
@htmlonly<center>@endhtmlonly
@image html /resources/occt_logo.png
@image latex /resources/occt_logo.png
@htmlonly</center>@endhtmlonly
@section OCCT_OVW_SECTION_1 Welcome
Welcome to Open CASCADE Technology (OCCT), a software development platform
@@ -11,12 +16,6 @@ visualization. Most of OCCT functionality is available in the form of C++
libraries. OCCT can be best applied in development of software dealing with 3D
modeling (CAD), manufacturing / measuring (CAM) or numerical simulation (CAE).
@htmlonly<center>@endhtmlonly
http://www.opencascade.org
@image html /resources/occt_logo.png
@image latex /resources/occt_logo.png
@htmlonly</center>@endhtmlonly
@section OCCT_OVW_SECTION_2 Copyrights
Open CASCADE Technology and all materials, including this documentation, is
@@ -170,42 +169,17 @@ See @ref occt_dev_guides__documentation "OCCT Documentation Guide" for details o
To generate HTML documentation from sources contained in *dox* subdirectory,
you need to have Tcl and Doxygen 1.8.5 (or above) installed on your system.
In Tcl prompt, cd to OCCT root folder and run
Use script **gendoc** (batch file on Windows, shell script on Linux / Mac OSX) to generate documentation.
tclsh> source dox/start.tcl
To generate Overview documentation:
On Windows you can also run batch script **gendoc.bat**.
cmd> gendoc -overview
To generate Reference manual:
**Generation of reference documentation**
cmd> gendoc -refman
Reference documentation can be generated with help of WOK tool that
is available for download from www.opencascade.org and dev.opencascade.org sites.
Prerequisites:
* Doxygen version 1.8.5 or higher
* Graphviz version 2.28.0 or higher
Run WOK (cd \<WOK_INSTALL_DIR\>/site folder):
* Using WOK TCL shell:
> wok_tclsh.sh
* Using Emacs editor:
> wok_emacs.sh
In the WOK prompt, step into your workbench:
> wokcd <your workbench>
In your workbench, use **wgendoc** command with h argument to get information about arguments of **wgendoc** command:
> wgendoc -h
then run **wgendoc** command with required arguments, for instance:
> wgendoc -output=d:/occt/doc {-m=Draw Visualization}
Run this command without arguments to get help on supported options.
@section OCCT_OVW_SECTION_5 Requirements

View File

@@ -58,7 +58,7 @@ This module also provides a variety of general-purpose services, such as:
Please, see the details in @ref occt_user_guides__foundation_classes "Foundation Classes User's Guide"
See also: our web site at <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section OCCT_TOVW_SECTION_3 Modeling Data
@@ -90,7 +90,7 @@ Please, see the details in @ref occt_user_guides__modeling_data "Modeling Data U
3D geometric models can be stored in OCCT native BREP format.
See @ref occt_user_guides__brep_wp "BREP Format Description White Paper" for details on the format.
See also: our web site at <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section OCCT_TOVW_SECTION_4 Modeling Algorithms
@@ -146,12 +146,10 @@ See @ref occt_user_guides__boolean_operations "Boolean Operations" User's Guide
* Algorithms for creation of mechanical features, i.e. depressions, protrusions, ribs and grooves or slots along planar or revolution surfaces.
@figure{/technical_overview/images/0004.png}
Please, see the details in @ref occt_user_guides__modeling_algos "Modeling Algorithms User's Guide".
See also: our web site at <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section OCCT_TOVW_SECTION_4a Mesh
@@ -165,8 +163,8 @@ Open CASCADE Technology includes two mesh converters:
- STL converter translates Open CASCADE shapes to STL files. STL (STtereoLithography) format is widely used for rapid prototyping (3D printing).
Open CASCADE SAS also offers Advanced Mesh Products:
- <a href="http://www.opencascade.org/support/products/omf">Open CASCADE Mesh Framework (OMF)</a>
- <a href="http://www.opencascade.org/support/products/emesh">Express Mesh</a>
- <a href="http://www.opencascade.com/content/mesh-framework">Open CASCADE Mesh Framework (OMF)</a>
- <a href="http://www.opencascade.com/content/express-mesh">Express Mesh</a>
@figure{/technical_overview/images/0003.png}
@@ -214,7 +212,7 @@ Open CASCADE Technology also supports voxel representation providing basic data
See @ref occt_user_guides__voxels_wp "Voxels User's Guide" for more information.
See also: our web site at <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section OCCT_TOVW_SECTION_6 Data Exchange
@@ -230,10 +228,10 @@ See also: our web site at <a href="http://www.opencascade.org/support/training/"
* @ref occt_user_guides__iges "IGES" (up to 5.3)
* VRML and STL meshes.
* @ref occt_user_guides__xde "Extended data exchange" (XDE) allows translating additional attributes attached to geometric data (colors, layers, names, materials etc).
* <a href="http://www.opencascade.org/support/products/dataex/">Advanced Data Exchange Components</a> are available in addition to standard Data Exchange interfaces to support interoperability and data adaptation (also using @ref OCCT_TOVW_SECTION_6a "Shape Healing") with CAD software using the following proprietary formats:
* <a href="http://www.opencascade.org/support/products/dataex/acis/">ACIS SAT</a>
* <a href="http://www.opencascade.org/support/products/dataex/parasolid/">Parasolid</a>
* <a href="http://www.opencascade.org/support/products/dataex/dxf/">DXF</a>
* <a href="http://www.opencascade.com/content/advanced-data-exchange-components">Advanced Data Exchange Components</a> are available in addition to standard Data Exchange interfaces to support interoperability and data adaptation (also using @ref OCCT_TOVW_SECTION_6a "Shape Healing") with CAD software using the following proprietary formats:
* <a href="http://www.opencascade.com/content/acis-sat-import-export">ACIS SAT</a>
* <a href="http://www.opencascade.com/content/parasolid-import">Parasolid</a>
* <a href="http://www.opencascade.com/content/dxf-import-export">DXF</a>
These components are based on the same architecture as interfaces with STEP and IGES.
@@ -271,7 +269,7 @@ Each sub-domain of Shape Healing has its own scope of functionality:
For more details refer to @ref occt_user_guides__shape_healing "Shape Healing User's guide".
See also: our web site at <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section OCCT_TOVW_SECTION_7 Application Framework
@@ -296,7 +294,7 @@ For more details see @ref occt_user_guides__ocaf "OCAF User's Guide" and the OCA
* @ref occt_user_guides__ocaf_tree_wp "Distribution of Data through OCAF Tree"
* @ref occt_user_guides__ocaf_functionmechanism_wp "Application Framework Function Mechanism"
See also: <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section OCCT_TOVW_SECTION_8 Draw Test Harness

View File

@@ -717,7 +717,7 @@ Congratulations! Your bottle is complete. Here is the result snapshot of the Tut
@image latex /tutorial/images/tutorial_image019.png
We hope that this tutorial has provided you with a feel for the industrial strength power of Open CASCADE Technology.
If you want to know more and develop major projects using Open CASCADE Technology, we invite you to study our training, support, and consulting services on our site at http://www.opencascade.org/support. Our professional services can maximize the power of your Open CASCADE Technology applications.
If you want to know more and develop major projects using Open CASCADE Technology, we invite you to study our training, support, and consulting services on our site at http://www.opencascade.com/content/technology-support. Our professional services can maximize the power of your Open CASCADE Technology applications.
@section sec6 Appendix

View File

@@ -1282,7 +1282,11 @@ Syntax:
~~~~~
vinit
~~~~~
Creates the 3D viewer window
Creates new View window with specified name view_name.
By default the new view is created in the viewer and in graphic driver shared with active view.
* *name* = {driverName/viewerName/viewName | viewerName/viewName | viewName}.
If driverName isn't specified the driver will be shared with active view.
If viewerName isn't specified the viewer will be shared with active view.
@subsubsection occt_draw_4_2_2 vhelp
@@ -1299,7 +1303,7 @@ Syntax:
vtop
~~~~~
Displays top view in the 3D viewer window.
Displays top view in the 3D viewer window. Orientation +X+Y.
**Example:**
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
@@ -1317,7 +1321,7 @@ Syntax:
vaxo
~~~~~
Displays axonometric view in the 3D viewer window.
Displays axonometric view in the 3D viewer window. Orientation +X-Y+Z.
**Example:**
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
@@ -1357,7 +1361,7 @@ Syntax:
~~~~~
vrepaint
~~~~~
Forcedly redisplays the shape in the 3D viewer window.
Forcebly redisplays the shape in the 3D viewer window.
@subsubsection occt_draw_4_2_8 vfit
@@ -1389,7 +1393,7 @@ Read pixel value for active view.
Syntax:
~~~~~
vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [shift_selection = 0|1]
vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [-allowoverlap 0|1] [shift_selection = 0|1]
~~~~~
Emulates different types of selection:
@@ -1397,6 +1401,7 @@ Emulates different types of selection:
* single mouse click selection
* selection with a rectangle having the upper left and bottom right corners in <i>(x1,y1)</i> and <i>(x2,y2)</i> respectively
* selection with a polygon having the corners in pixel positions <i>(x1,y1), (x2,y2),…, (xn,yn)</i>
* -allowoverlap manages overlap and inclusion detection in rectangular selection. If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined rectangle will be detected, otherwise algorithm will chose only fully included sensitives. Default behavior is to detect only full inclusion.
* any of these selections if shift_selection is set to 1.
@subsubsection occt_draw_4_2_12 vmoveto
@@ -1412,9 +1417,18 @@ Emulates cursor movement to pixel position (x,y).
Syntax:
~~~~~
vviewparams [scale center_X center_Y proj_X proj_Y proj_Z up_X up_Y up_Z at_X at_Y at_Z]
vviewparams [-scale [s]] [-eye [x y z]] [-at [x y z]] [-up [x y z]] [-proj [x y z]] [-center x y] [-size sx]
~~~~~
Gets or sets the current view characteristics.
Gets or sets current view parameters.
* If called without arguments, all view parameters are printed.
* The options are:
* -scale [s] : prints or sets viewport relative scale.
* -eye [x y z] : prints or sets eye location.
* -at [x y z] : prints or sets center of look.
* -up [x y z] : prints or sets direction of up vector.
* -proj [x y z] : prints or sets direction of look.
* -center x y : sets location of center of the screen in pixels.
* -size [sx] : prints viewport projection width and height sizes or changes the size of its maximum dimension.
@subsubsection occt_draw_4_2_14 vchangeselected
@@ -1463,9 +1477,11 @@ Removes structures which do not belong to objects displayed in neutral point.
Syntax:
~~~~~
vhlr is_enabled={on|off}
vhlr is_enabled={on|off} [show_hidden={1|0}]
~~~~~
Switches hidden line removal (computed) mode on/off.
Hidden line removal algorithm:
* is_enabled: if is on HLR algorithm is applied.
* show_hidden: if equals to 1, hidden lines are drawn as dotted ones.
@subsubsection occt_draw_4_2_20 vhlrtype
@@ -1485,10 +1501,30 @@ If no shape is specified through the command arguments, the given HLR algorithm_
Syntax:
~~~~~
vcamera
vcamera [-ortho] [-projtype]
[-persp]
[-fovy [Angle]] [-distance [Distance]]
[-stereo] [-leftEye] [-rightEye]
[-iod [Distance]] [-iodType [absolute|relative]]
[-zfocus [Value]] [-zfocusType [absolute|relative]]
~~~~~
Manages camera parameters.
Manage camera parameters.
Prints current value when option called without argument.
Orthographic camera:
* -ortho activate orthographic projection
Perspective camera:
* -persp activate perspective projection (mono)
* -fovy field of view in y axis, in degrees
* -distance distance of eye from camera center
Stereoscopic camera:
* -stereo perspective projection (stereo)
* -leftEye perspective projection (left eye)
* -rightEye perspective projection (right eye)
* -iod intraocular distance value
* -iodType distance type, absolute or relative
* -zfocus stereographic focus value
* -zfocusType focus type, absolute or relative"
**Example:**
~~~~~
@@ -1503,10 +1539,20 @@ vcamera -persp
Syntax:
~~~~~
vstereo [0:1]
vstereo [0|1] [-mode Mode] [-reverse {0|1}] [-anaglyph Filter]
~~~~~
Turns stereo usage On/Off.
Control stereo output mode.
Available modes for -mode:
* quadBuffer - OpenGL QuadBuffer stereo, requires driver support. Should be called BEFORE vinit!
* anaglyph - Anaglyph glasses
* rowInterlaced - row-interlaced display
* columnInterlaced - column-interlaced display
* chessBoard - chess-board output
* sideBySide - horizontal pair
* overUnder - vertical pair
Available Anaglyph filters for -anaglyph:
* redCyan, redCyanSimple, yellowBlue, yellowBlueSimple, greenMagentaSimple
**Example:**
~~~~~
@@ -1536,11 +1582,33 @@ Enables/disables objects clipping.
Syntax:
~~~~~
vdisplay [-noupdate|-update] [-local] [-mutable] name1 [name2] … [name n]
vdisplay [-noupdate|-update] [-local] [-mutable] [-neutral]
[-trsfPers {pan|zoom|rotate|trihedron|full|none}=none] [-trsfPersPos X Y [Z]] [-3d|-2d|-2dTopDown]
[-dispMode mode] [-highMode mode]
[-layer index] [-top|-topmost|-overlay|-underlay]
[-redisplay]
name1 [name2] ... [name n]
~~~~~
Displays named objects. Automatically redraws view by default.
Redraw can be suppressed by -noupdate option.
Displays named objects.
Option -local enables displaying of objects in local selection context.
Local selection context will be opened if there is not any.
* *noupdate* suppresses viewer redraw call.
* *mutable* enables optimizations for mutable objects.
* *neutral* draws objects in main viewer.
* *layer* sets z-layer for objects. It can use '-overlay|-underlay|-top|-topmost' instead of '-layer index' for the default z-layers.
* *top* draws objects on top of main presentations but below topmost.
* *topmost* draws in overlay for 3D presentations with independent Depth.
* *overlay* draws objects in overlay for 2D presentations (On-Screen-Display).
* *underlay* draws objects in underlay for 2D presentations (On-Screen-Display).
* *selectable|-noselect* controls selection of objects.
* *trsfPers* sets a transform persistence flags. Flag 'full' is pan, zoom and rotate.
* *trsfPersPos* sets an anchor point for transform persistence.
* *2d|-2dTopDown* displays object in screen coordinates.
* *dispmode* sets display mode for objects.
* *highmode* sets hilight mode for objects.
* *redisplay* recomputes presentation of objects.
**Example:**
~~~~~
@@ -1555,7 +1623,7 @@ vfit
Syntax:
~~~~~
vdonly [name1] [name n]
vdonly [-noupdate|-update] [name1] ... [name n]
~~~~~
Displays only selected or named objects. If there are no selected or named objects, nothing is done.
@@ -1573,10 +1641,11 @@ vfit
Syntax:
~~~~~
vdisplayall
vdisplayall [-local]
~~~~~
Displays all created objects.
Displays all erased interactive objects (see vdir and vstate).
Option -local enables displaying of the objects in local selection context.
**Example:**
~~~~~
@@ -1688,18 +1757,30 @@ Makes a list of known types and signatures in AIS.
Syntax:
~~~~~
vaspects [-noupdate|-update] [name1 [name2 [...]]]
[-setcolor ColorName] [-setcolor R G B] [-unsetcolor]
[-setmaterial MatName] [-unsetmaterial]
[-settransparency Transp] [-unsettransparency]
[-setwidth LineWidth] [-unsetwidth]
vaspects [-noupdate|-update] [name1 [name2 [...]] | -defaults]
[-setVisibility 0|1]
[-setColor ColorName] [-setcolor R G B] [-unsetColor]
[-setMaterial MatName] [-unsetMaterial]
[-setTransparency Transp] [-unsetTransparency]
[-setWidth LineWidth] [-unsetWidth]
[-setLineType {solid|dash|dot|dotDash}] [-unsetLineType]
[-freeBoundary {off/on | 0/1}]
[-setFreeBoundaryWidth Width] [-unsetFreeBoundaryWidth]
[-setFreeBoundaryColor {ColorName | R G B}] [-unsetFreeBoundaryColor]
[-subshapes subname1 [subname2 [...]]]
[-isoontriangulation 0|1]
[-setMaxParamValue {value}]
~~~~~
Manage presentation properties of all, selected or named objects.
When *-subshapes* is specified than following properties will be assigned to specified sub-shapes.
When *-defaults* is specified than presentation properties will be assigned to all objects that have not their own specified properties and to all objects to be displayed in the future.
If *-defaults* is used there should not be any objects' names and -subshapes specifier.
Aliases:
~~~~~
vsetcolor [shapename] colorname
vsetcolor [-noupdate|-update] [name] ColorName
~~~~~
@@ -1778,7 +1859,7 @@ Syntax:
vunsetshading [shapename]
~~~~~
Sets default deflection coefficient (0.0008) that defines the quality of the shapes representation in the shading mode. Default coefficient is 0.0008.
Sets default deflection coefficient (0.0008) that defines the quality of the shapes representation in the shading mode.
@subsubsection occt_draw_4_3_13 vsetam
@@ -1819,7 +1900,10 @@ Deactivates all selection modes for all shapes.
Syntax:
~~~~~
vdump <filename>.{png|bmp|jpg|gif}
vdump <filename>.{png|bmp|jpg|gif} [-width Width -height Height]
[-buffer rgb|rgba|depth=rgb]
[-stereo mono|left|right|blend|sideBySide|overUnder=mono]
~~~~~
Extracts the contents of the viewer window to a image file.
@@ -1853,24 +1937,6 @@ vsetdispmode 1
vsub b 1
~~~~~
@subsubsection occt_draw_4_3_18 vardis
Syntax:
~~~~~
vardis
~~~~~
Displays active areas (for each activated sensitive entity, one or several 2D bounding boxes are displayed, depending on the implementation of a particular entity).
@subsubsection occt_draw_4_3_19 varera
Syntax:
~~~~~
varera
~~~~~
Erases active areas.
@subsubsection occt_draw_4_3_20 vsensdis
Syntax:
@@ -1939,10 +2005,12 @@ vr myshape.brep
Syntax:
~~~~~
vstate [name1] [name n]
vstate [-entities] [-hasSelected] [name1] ... [nameN]
~~~~~
Makes a list of the status (**Displayed** or **Not Displayed**) of some selected or named objects.
Reports show/hidden state for selected or named objects
* *entities* - print low-level information about detected entities
* *hasSelected* - prints 1 if context has selected shape and 0 otherwise
@subsubsection occt_draw_4_3_25 vraytrace
@@ -1957,18 +2025,27 @@ Turns on/off ray tracing renderer.
Syntax:
~~~~~
vrenderparams
vrenderparams [-rayTrace|-raster] [-rayDepth 0..10] [-shadows {on|off}]
[-reflections {on|off}] [-fsaa {on|off}] [-gleam {on|off}]
[-gi {on|off}] [-brng {on|off}] [-env {on|off}]
[-shadin {color|flat|gouraud|phong}]
~~~~~
Manages rendering parameters:
* rayTrace
* raster
* rayDepth
* shadows
* reflections
* fsaa
* gleam
* shadingModel
* rayTrace - Enables GPU ray-tracing
* raster - Disables GPU ray-tracing
* rayDepth - Defines maximum ray-tracing depth
* shadows - Enables/disables shadows rendering
* reflections - Enables/disables specular reflections
* fsaa - Enables/disables adaptive anti-aliasing
* gleam - Enables/disables transparency shadow effects
* gi - Enables/disables global illumination effects
* brng - Enables/disables blocked RNG (fast coherent PT)
* env - Enables/disables environment map background
* shadingModel - Controls shading model from enumeration color, flat, gouraud, phong
Unlike vcaps, these parameters dramatically change visual properties.
Command is intended to control presentation quality depending on hardware capabilities and performance.
**Example:**
~~~~~
@@ -1983,7 +2060,9 @@ vrenderparams -shadows 1 -reflections 1 -fsaa 1
Syntax:
~~~~~
vshaderprog [name] pathToVertexShader pathToFragmentShader
'vshaderprog [name] pathToVertexShader pathToFragmentShader'
or 'vshaderprog [name] off' to disable GLSL program
or 'vshaderprog [name] phong' to enable per-pixel lighting calculations
~~~~~
Enables rendering using a shader program.
@@ -2027,7 +2106,7 @@ Syntax:
vplanetri name
~~~~~
Creates a plane from a trihedron selection.
Create a plane from a trihedron selection. If no arguments are set, the default
@subsubsection occt_draw_4_4_3 vsize
@@ -2067,7 +2146,7 @@ vaxis axe1 0 0 0 1 0 0
Syntax:
~~~~~
vaxispara nom
vaxispara name
~~~~~
Creates an axis by interactive selection of an edge and a vertex.
@@ -2106,7 +2185,10 @@ vplane name [PlaneName] [PointName]
~~~~~
Creates a plane from named or interactively selected entities.
TypeOfSensitivity:
* 0 - Interior
* 1 - Boundary
**Example:**
~~~~~
vinit
@@ -2187,11 +2269,24 @@ Creates a plane with a 2D trihedron from an interactively selected face.
Syntax:
~~~~~
vselmode [object] mode On/Off
vselmode [object] mode_number is_turned_on=(1|0)
~~~~~
Sets the selection mode for an object. If the object value is not defined, the selection mode is set for all displayed objects.
Value *On* is defined as 1 and *Off* as 0.
*Mode_number* is non-negative integer that has different meaning for different interactive object classes.
For shapes the following *mode_number* values are allowed:
* 0 - shape
* 1 - vertex
* 2 - edge
* 3 - wire
* 4 - face
* 5 - shell
* 6 - solid
* 7 - compsolid
* 8 - compound
*is_turned_on* is:
* 1 if mode is to be switched on
* 0 if mode is to be switched off
**Example:**
~~~~~
@@ -2202,16 +2297,14 @@ vpoint p3 25 40 0
vtriangle triangle1 p1 p2 p3
~~~~~
@subsubsection occt_draw_4_4_15 vconnect, vconnectsh
@subsubsection occt_draw_4_4_15 vconnect
Syntax:
~~~~~
vconnect name object Xo Yo Zo Xu Xv Xw Zu Zv Zw
vconnectsh name shape Xo Yo Zo Xu Xv Xw Zu Zv Zw
vconnect vconnect name Xo Yo Zo object1 object2 ... [color=NAME]
~~~~~
Creates and displays an object with input location connected to a named entity.
The difference between these two commands is that the object created by *vconnect* does not support the selection modes different from 0.
Creates and displays AIS_ConnectedInteractive object from input object and location
**Example:**
~~~~~
@@ -2221,7 +2314,7 @@ vpoint p2 50 0 0
vsegment segment p1 p2
restore CrankArm.brep obj
vdisplay obj
vconnectsh new obj 100100100 1 0 0 0 0 1
vconnect new obj 100100100 1 0 0 0 0 1
~~~~~
@subsubsection occt_draw_4_4_16 vtriangle
@@ -2263,15 +2356,23 @@ vsegment segment p1 p2
Syntax:
~~~~~
vpointcloud name shape
vpointcloud name shape [-randColor] [-normals] [-noNormals]
~~~~~
Creates an interactive object for an arbitary set of points from the triangulated shape.
Additional options:
* *randColor* - generate random color per point
* *normals* - generate normal per point (default)
* *noNormals* - do not generate normal per point
~~~~~
vpointcloud name x y z r npts {surface|volume}
vpointcloud name x y z r npts {surface|volume} [-randColor] [-normals] [-noNormals]
~~~~~
Creates an arbitrary set of points (npts) randomly distributed on a spheric surface or within a spheric volume (x y z r).
Additional options:
* *randColor* - generate random color per point
* *normals* - generate normal per point (default)
* *noNormals* - do not generate normal per point
**Example:**
~~~~~

View File

@@ -5,7 +5,7 @@ Foundation Classes {#occt_user_guides__foundation_classes}
@section occt_fcug_1 Introduction
This manual explains how to use Open CASCADE Technology (**OCCT**) Foundation Classes. It provides basic documentation on foundation classes. For advanced information on foundation classes and their applications, see the offerings on our web site at <a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>.
This manual explains how to use Open CASCADE Technology (**OCCT**) Foundation Classes. It provides basic documentation on foundation classes. For advanced information on foundation classes and their applications, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
Foundation Classes provide a variety of general-purpose services such as automated dynamic memory management (manipulation of objects by handle), collections, exception handling, genericity by down-casting and plug-in creation.
@@ -746,7 +746,7 @@ then, the *Value* function may be implemented as follows:
Item TCollection_Array1::Value (const Standard_Integer&index) const
{
// where r1 and r2 are the lower and upper bounds of the array
if(index r1 || index > r2) {
if(index < r1 || index > r2) {
OutOfRange::Raise(“Index out of range in Array1::Value”);
}
return contents[index];
@@ -754,26 +754,26 @@ Item TCollection_Array1::Value (const Standard_Integer&index) const
~~~~~
Here validity of the index is first verified using the Lower and Upper functions in order to protect the call.
Normally the caller ensures the index being in the valid range before calling Value(). In this case the above implementation of Value is not optimal since the test done in Value is time-consuming and redundant.
Normally the caller ensures the index being in the valid range before calling <i>Value()</i>. In this case the above implementation of *Value* is not optimal since the test done in *Value* is time-consuming and redundant.
It is a widely used practice to include that kind of protections in a debug build of the program and exclude in release (optimized) build. To support this practice, the macros Raise_if() are provided for every OCCT exception class:
It is a widely used practice to include that kind of protections in a debug build of the program and exclude in release (optimized) build. To support this practice, the macros <i>Raise_if()</i> are provided for every OCCT exception class:
~~~~~
<ErrorTypeName>_Raise_if(condition, “Error message”);
~~~~~
where ErrorTypeName is the exception type, condition is the logical expression leading to the raise of the exception, and Error message is the associated message.
where *ErrorTypeName* is the exception type, *condition* is the logical expression leading to the raise of the exception, and *Error message* is the associated message.
The entire call may be removed by defining one of the pre-processor symbols No_Exception or No_<ErrorTypeName> at compile-time:
The entire call may be removed by defining one of the pre-processor symbols *No_Exception* or <i>No_<ErrorTypeName></i> at compile-time:
~~~~~
#define No_Exception /* remove all raises */
~~~~~
Using this syntax, the Value function becomes:
Using this syntax, the *Value* function becomes:
~~~~~
Item TCollection_Array1::Value (const Standard_Integer&index) const
{
OutOfRange_Raise_if(index r1 || index > r2,
OutOfRange_Raise_if(index < r1 || index > r2,
“index out of range in Array1::Value”);
return contents[index];
}
@@ -789,7 +789,7 @@ A handler of T exception type is a match for a raise expression with an excepti
* T and E are of the same type, or
* T is a supertype of E.
In order to handle system signals as exceptions, make sure to insert macro OCC_CATCH_SIGNALS somewhere in the beginning of the relevant code. The recommended location for it is first statement after opening brace of try {} block.
In order to handle system signals as exceptions, make sure to insert macro *OCC_CATCH_SIGNALS* somewhere in the beginning of the relevant code. The recommended location for it is first statement after opening brace of <i>try {}</i> block.
As an example, consider the exceptions of type *NumericError, Overflow, Underflow* and *ZeroDivide*, where *NumericError* is the parent type of the three others.

View File

@@ -15,7 +15,7 @@ Please, note:
* an IGES entity is an entity in the IGES normal sense.
* a root entity is the highest level entity of any given type, e.g. type 144 for surfaces and type 186 for solids. Roots are not referenced by other entities.
This manual mainly explains how to convert an IGES file to an Open CASCADE Technology (**OCCT**) shape and vice versa. It provides basic documentation on conversion. For advanced information on conversion, see our offerings on our web site at <a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>
This manual mainly explains how to convert an IGES file to an Open CASCADE Technology (**OCCT**) shape and vice versa. It provides basic documentation on conversion. For advanced information on conversion, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
IGES files produced in accordance with IGES standard versions up to and including version 5.3 can be read. IGES files that are produced by this interface conform to IGES version 5.3 (Initial Graphics Exchange Specification, IGES 5.3. ANS US PRO/IPO-100-1996).

View File

@@ -5,7 +5,7 @@ Modeling Algorithms {#occt_user_guides__modeling_algos}
@section occt_modalg_1 Introduction
This manual explains how to use the Modeling Algorithms. It provides basic documentation on modeling algorithms. For advanced information on Modeling Algorithms, see our offerings on our web site at <a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>
This manual explains how to use the Modeling Algorithms. It provides basic documentation on modeling algorithms. For advanced information on Modeling Algorithms, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
The Modeling Algorithms module brings together a wide range of topological algorithms used in modeling. Along with these tools, you will find the geometric algorithms, which they call.
@@ -489,7 +489,7 @@ The Curves and Surfaces from Constraints component groups together high level fu
* construction of plate surfaces
* extension of a 3D curve or surface beyond its original bounds.
OPEN CASCADE company also provides a product known as <a href="http://www.opencascade.org/support/products/ssp/">Surfaces from Scattered Points</a>, which allows constructing surfaces from scattered points. This algorithm accepts or constructs an initial B-Spline surface and looks for its deformation (finite elements method) which would satisfy the constraints. Using optimized computation methods, this algorithm is able to construct a surface from more than 500 000 points.
OPEN CASCADE company also provides a product known as <a href="http://www.opencascade.com/content/surfaces-scattered-points">Surfaces from Scattered Points</a>, which allows constructing surfaces from scattered points. This algorithm accepts or constructs an initial B-Spline surface and looks for its deformation (finite elements method) which would satisfy the constraints. Using optimized computation methods, this algorithm is able to construct a surface from more than 500 000 points.
SSP product is not supplied with Open CASCADE Technology, but can be purchased separately.
@@ -2878,8 +2878,8 @@ Open CASCADE Technology includes two mesh converters:
- STL converter translates Open CASCADE shapes to STL files. STL (STtereoLithography) format is widely used for rapid prototyping.
Open CASCADE SAS also offers Advanced Mesh Products:
- <a href="http://www.opencascade.org/support/products/omf">Open CASCADE Mesh Framework (OMF)</a>
- <a href="http://www.opencascade.org/support/products/emesh">Express Mesh</a>
- <a href="http://www.opencascade.com/content/mesh-framework">Open CASCADE Mesh Framework (OMF)</a>
- <a href="http://www.opencascade.com/content/express-mesh">Express Mesh</a>
Besides, we can efficiently help you in the fields of surface and volume meshing algorithms, mesh optimization algorithms etc. If you require a qualified advice about meshing algorithms, do not hesitate to benefit from the expertise of our team in that domain.

View File

@@ -7,7 +7,7 @@ Modeling Data {#occt_user_guides__modeling_data}
Modeling Data supplies data structures to represent 2D and 3D geometric models.
This manual explains how to use Modeling Data. For advanced information on modeling data, see our offerings on our web site at <a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>.
This manual explains how to use Modeling Data. For advanced information on modeling data, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section occt_modat_1 Geometry Utilities

View File

@@ -7,8 +7,7 @@ OCAF {#occt_user_guides__ocaf}
This manual explains how to use the Open CASCADE Application Framework (OCAF).
It provides basic documentation on using OCAF. For advanced information on OCAF
and its applications, see our offerings on our web site at
<a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>
and its applications, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
OCAF (the Open CASCADE Application Framework) is a RAD (Rapid Application Development) framework used for
specifying and organizing application data. To do this, OCAF provides:

View File

@@ -7,7 +7,7 @@ Shape Healing {#occt_user_guides__shape_healing}
@subsection occt_shg_1_1 Introduction
This manual explains how to use Shape Healing. It provides basic documentation on its operation. For advanced information on Shape Healing and its applications, see our offerings on our web site at <a href="http://www.opencascade.org/support/training/">www.opencascade.org/support/training/</a>
This manual explains how to use Shape Healing. It provides basic documentation on its operation. For advanced information on Shape Healing and its applications, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
The **Shape Healing** toolkit provides a set of tools to work on the geometry and topology of Open CASCADE Technology (**OCCT**) shapes. Shape Healing adapts shapes so as to make them as appropriate for use by Open CASCADE Technology as possible.

View File

@@ -24,7 +24,7 @@ File translation is performed in the programming mode, via C++ calls.
For testing the STEP component in DRAW Test Harness, a set of commands for reading and writing STEP files and analysis of relevant data are provided by the *TKXSDRAW* plugin.
See also: our web site at <a href="http://www.opencascade.org/support/training/">E-learning and Training</a>.
See also our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@subsection occt_step_1_1 STEP Exchanges in Open Cascade technology

View File

@@ -35,6 +35,8 @@ To answer different needs of CASCADE users, this User's Guide offers the followi
* If the 3D services proposed in AIS meet your requirements, you need only read chapter 3 <a href="#occt_visu_3">AIS: Application Interactive Services</a>.
* If you need more detail, for example, a selection filter on another type of entity - you should read chapter 2 <a href="#occt_visu_2">Fundamental Concepts</a>, chapter 3 <a href="#occt_visu_3">AIS: Application Interactive Services</a>, and 4 <a href="#occt_visu_4">3D Presentations</a>. You may want to begin with the chapter presenting AIS.
For advanced information on visualization algorithms, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
@section occt_visu_2 Fundamental Concepts

View File

@@ -5,7 +5,7 @@
@section occt_xde_1 Introduction
This manual explains how to use the Extended Data Exchange (XDE). It provides basic documentation on setting up and using XDE. For advanced information on XDE and its applications, see our offerings at <a href="http://www.opencascade.com/services/support/">on our web site</a>.
This manual explains how to use the Extended Data Exchange (XDE). It provides basic documentation on setting up and using XDE. For advanced information on XDE and its applications, see our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.
The Extended Data Exchange (XDE) module allows extending the scope of exchange by translating additional data attached to geometric BREP data, thereby improving the interoperability with external software.

View File

@@ -590,10 +590,8 @@ public:
{
return;
}
for(myAISContext()->InitCurrent();myAISContext()->MoreCurrent();myAISContext()->NextCurrent())
{
myAISContext()->Erase(myAISContext()->Current(),Standard_True);
}
myAISContext()->EraseSelected (Standard_True);
myAISContext()->ClearCurrents();
}

View File

@@ -642,10 +642,8 @@ public:
{
return;
}
for(myAISContext()->InitCurrent(); myAISContext()->MoreCurrent(); myAISContext()->NextCurrent())
{
myAISContext()->Erase (myAISContext()->Current(), Standard_True);
}
myAISContext()->EraseSelected (Standard_True);
myAISContext()->ClearCurrents();
}

View File

@@ -461,24 +461,6 @@
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.cpp">
<Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Disabled</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">EnableFastChecks</BasicRuntimeChecks>
<BrowseInformation Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</BrowseInformation>
<Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Disabled</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">EnableFastChecks</BasicRuntimeChecks>
<BrowseInformation Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</BrowseInformation>
<Optimization Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MaxSpeed</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
<Optimization Condition="'$(Configuration)|$(Platform)'=='Release|x64'">MaxSpeed</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession_Curve.cpp">
<Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Disabled</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
@@ -592,7 +574,6 @@
<ClInclude Include="..\..\..\src\GeometryView2D.h" />
<ClInclude Include="..\..\..\src\GeomSources.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_Curve.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession_Curve.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession_Direction.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession_Point.h" />

View File

@@ -54,9 +54,6 @@
<ClCompile Include="..\..\..\src\ISession2D\ISession2D_Curve.cpp">
<Filter>Source Files\ISession2d</Filter>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.cpp">
<Filter>Source Files\ISession2d</Filter>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession_Curve.cpp">
<Filter>Source Files\ISession2d</Filter>
</ClCompile>
@@ -106,9 +103,6 @@
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_Curve.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\..\src\ISession2D\ISession_Curve.h">
<Filter>Header Files</Filter>
</ClInclude>

View File

@@ -461,24 +461,6 @@
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.cpp">
<Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Disabled</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">EnableFastChecks</BasicRuntimeChecks>
<BrowseInformation Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</BrowseInformation>
<Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Disabled</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">EnableFastChecks</BasicRuntimeChecks>
<BrowseInformation Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</BrowseInformation>
<Optimization Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MaxSpeed</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
<Optimization Condition="'$(Configuration)|$(Platform)'=='Release|x64'">MaxSpeed</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession_Curve.cpp">
<Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Disabled</Optimization>
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
@@ -592,7 +574,6 @@
<ClInclude Include="..\..\..\src\GeometryView2D.h" />
<ClInclude Include="..\..\..\src\GeomSources.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_Curve.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession_Curve.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession_Direction.h" />
<ClInclude Include="..\..\..\src\ISession2D\ISession_Point.h" />

View File

@@ -54,9 +54,6 @@
<ClCompile Include="..\..\..\src\ISession2D\ISession2D_Curve.cpp">
<Filter>Source Files\ISession2d</Filter>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.cpp">
<Filter>Source Files\ISession2d</Filter>
</ClCompile>
<ClCompile Include="..\..\..\src\ISession2D\ISession_Curve.cpp">
<Filter>Source Files\ISession2d</Filter>
</ClCompile>
@@ -106,9 +103,6 @@
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_Curve.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\..\src\ISession2D\ISession_Curve.h">
<Filter>Header Files</Filter>
</ClInclude>

View File

@@ -999,54 +999,6 @@
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.cpp"
>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession_Curve.cpp"
>
@@ -1329,10 +1281,6 @@
RelativePath="..\..\..\src\ISession2D\ISession2D_Curve.h"
>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.h"
>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession_Curve.h"
>

View File

@@ -996,54 +996,6 @@
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.cpp"
>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
<FileConfiguration
Name="Release|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Debug|x64"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession_Curve.cpp"
>
@@ -1326,10 +1278,6 @@
RelativePath="..\..\..\src\ISession2D\ISession2D_Curve.h"
>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession2D_SensitiveCurve.h"
>
</File>
<File
RelativePath="..\..\..\src\ISession2D\ISession_Curve.h"
>

View File

@@ -87,7 +87,7 @@ COcafDoc::~COcafDoc()
Handle(TOcaf_Application) OcafApp= ((COcafApp*)AfxGetApp())->GetApp(); \n\
\n\
// Creating the new document \n\
OcafApp->NewDocument(\"Ocaf-Sample\", myOcafDoc); \n\
OcafApp->NewDocument(\"MDTV-Standard\", myOcafDoc); \n\
\n\
// Creation of a new TPrsStd_AISViewer connected to the current V3d_Viewer\n\
TPrsStd_AISViewer::New(myOcafDoc->Main(),myViewer); \n\
@@ -1068,7 +1068,7 @@ m_App->SaveAs(myOcafDoc,(TCollection_ExtendedString) TPath); \n\
else
{
// The document must be saved in standard format
myOcafDoc->ChangeStorageFormat("Ocaf-Sample");
myOcafDoc->ChangeStorageFormat("MDTV-Standard");
}
try

View File

@@ -188,14 +188,17 @@ void CHLRDoc::Fit()
void CHLRDoc::OnObjectErase()
{
Standard_Boolean toUpdateDisplayable = Standard_False;
for (myAISContext->InitCurrent(); myAISContext->MoreCurrent(); myAISContext->NextCurrent())
myAISContext->InitCurrent();
while (myAISContext->MoreCurrent())
{
myAISContext->Erase (myAISContext->Current(), Standard_True);
if (myAISContext->Current()->Type() == AIS_KOI_Shape && myCSelectionDialogIsCreated)
{
myCSelectionDialog->DiplayableShape()->Remove (Handle(AIS_Shape)::DownCast (myAISContext->Current())->Shape());
toUpdateDisplayable = Standard_True;
}
myAISContext->Erase (myAISContext->Current(), Standard_True);
myAISContext->InitCurrent();
}
myAISContext->ClearCurrents();

View File

@@ -293,10 +293,7 @@ void OCC_3dBaseDoc::OnUpdateObjectColor(CCmdUI* pCmdUI)
void OCC_3dBaseDoc::OnObjectErase()
{
for (myAISContext->InitCurrent(); myAISContext->MoreCurrent(); myAISContext->NextCurrent())
{
myAISContext->Erase (myAISContext->Current(), Standard_True);
}
myAISContext->EraseSelected();
myAISContext->ClearCurrents();
}
void OCC_3dBaseDoc::OnUpdateObjectErase(CCmdUI* pCmdUI)

View File

@@ -66,16 +66,16 @@
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../win32\vc10\libd\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../win32\vc10\bind\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\win32\objd\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">../../../../win64\vc10\libd\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">../../../../win64\vc10\bind\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\win64\objd\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../win32\vc10\lib\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../win32\vc10\bin\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\win32\obj\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">../../../../win64\vc10\lib\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">../../../../win64\vc10\bin\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\win64\obj\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
</PropertyGroup>
@@ -112,14 +112,13 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;FWOSPlugin.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win32\vc10\libd/mfcsample.dll</OutputFile>
<OutputFile>../../../../win32\vc10\bind/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>../../../../win32\vc10\libd/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win32\vc10\bind/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win32\vc10\libd/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -156,14 +155,13 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;FWOSPlugin.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win64\vc10\libd/mfcsample.dll</OutputFile>
<OutputFile>../../../../win64\vc10\bind/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>../../../../win64\vc10\libd/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win64\vc10\bind/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win64\vc10\libd/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -201,13 +199,12 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win32\vc10\lib/mfcsample.dll</OutputFile>
<OutputFile>../../../../win32\vc10\bin/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>../../../../win32\vc10\lib/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win32\vc10\bin/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win32\vc10\lib/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -246,13 +243,12 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win64\vc10\lib/mfcsample.dll</OutputFile>
<OutputFile>../../../../win64\vc10\bin/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>../../../../win64\vc10\lib/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win64\vc10\bin/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win64\vc10\lib/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>

View File

@@ -70,16 +70,16 @@
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../win32\vc11\libd\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../win32\vc11\bind\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\win32\objd\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">../../../../win64\vc11\libd\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">../../../../win64\vc11\bind\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\win64\objd\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../win32\vc11\lib\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../win32\vc11\bin\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\win32\obj\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">../../../../win64\vc11\lib\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">../../../../win64\vc11\bin\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\win64\obj\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
</PropertyGroup>
@@ -116,14 +116,13 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;FWOSPlugin.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win32\vc11\libd/mfcsample.dll</OutputFile>
<OutputFile>../../../../win32\vc11\bind/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>../../../../win32\vc11\libd/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win32\vc11\bind/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win32\vc11\libd/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -160,14 +159,13 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;FWOSPlugin.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win64\vc11\libd/mfcsample.dll</OutputFile>
<OutputFile>../../../../win64\vc11\bind/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>../../../../win64\vc11\libd/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win64\vc11\bind/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win64\vc11\libd/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -205,13 +203,12 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win32\vc11\lib/mfcsample.dll</OutputFile>
<OutputFile>../../../../win32\vc11\bin/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>../../../../win32\vc11\lib/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win32\vc11\bin/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win32\vc11\lib/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -250,13 +247,12 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win64\vc11\lib/mfcsample.dll</OutputFile>
<OutputFile>../../../../win64\vc11\bin/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>../../../../win64\vc11\lib/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win64\vc11\bin/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win64\vc11\lib/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>

View File

@@ -70,16 +70,16 @@
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../win32\vc12\libd\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../../../win32\vc12\bind\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\win32\objd\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">../../../../win64\vc12\libd\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">../../../../win64\vc12\bind\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\win64\objd\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../win32\vc12\lib\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../../win32\vc12\bin\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">.\win32\obj\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">../../../../win64\vc12\lib\</OutDir>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">../../../../win64\vc12\bin\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\win64\obj\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>
</PropertyGroup>
@@ -116,14 +116,13 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;FWOSPlugin.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win32\vc12\libd/mfcsample.dll</OutputFile>
<OutputFile>../../../../win32\vc12\bind/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>../../../../win32\vc12\libd/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win32\vc12\bind/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win32\vc12\libd/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -160,14 +159,13 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;FWOSPlugin.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win64\vc12\libd/mfcsample.dll</OutputFile>
<OutputFile>../../../../win64\vc12\bind/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB64D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>../../../../win64\vc12\libd/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win64\vc12\bind/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win64\vc12\libd/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -205,13 +203,12 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win32\vc12\lib/mfcsample.dll</OutputFile>
<OutputFile>../../../../win32\vc12\bin/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>../../../../win32\vc12\lib/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win32\vc12\bin/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win32\vc12\lib/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
@@ -250,13 +247,12 @@
</ResourceCompile>
<Link>
<AdditionalDependencies>TKVrml.lib;TKStl.lib;TKBrep.lib;TKIGES.lib;TKShHealing.lib;TKStep.lib;TKXSBase.lib;TKShapeSchema.lib;PTKernel.lib;TKBool.lib;TKCAF.lib;TKCDF.lib;TKernel.lib;TKFeat.lib;TKFillet.lib;TKG2d.lib;TKG3d.lib;TKGeomAlgo.lib;TKGeomBase.lib;TKHLR.lib;TKMath.lib;TKOffset.lib;TKPCAF.lib;TKPrim.lib;TKPShape.lib;TKService.lib;TKTopAlgo.lib;TKMesh.lib;TKV3d.lib;TKOpenGl.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>../../../../win64\vc12\lib/mfcsample.dll</OutputFile>
<OutputFile>../../../../win64\vc12\bin/mfcsample.dll</OutputFile>
<SuppressStartupBanner>true</SuppressStartupBanner>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB64);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>../../../../win64\vc12\lib/mfcsample.pdb</ProgramDatabaseFile>
<ProgramDatabaseFile>../../../../win64\vc12\bin/mfcsample.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
<ImportLibrary>
</ImportLibrary>
<ImportLibrary>../../../../win64\vc12\lib/mfcsample.lib</ImportLibrary>
<TargetMachine>MachineX64</TargetMachine>
</Link>
</ItemDefinitionGroup>

View File

@@ -20,7 +20,7 @@
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="../../../../win32\vc8\libd"
OutputDirectory="../../../../win32\vc8\bind"
IntermediateDirectory=".\win32\objd"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -81,14 +81,14 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib FWOSPlugin.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win32\vc8\libd/mfcsample.dll"
OutputFile="../../../../win32\vc8\bind/mfcsample.dll"
LinkIncremental="2"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB32D)"
GenerateDebugInformation="true"
ProgramDatabaseFile="../../../../win32\vc8\libd/mfcsample.pdb"
ProgramDatabaseFile="../../../../win32\vc8\bind/mfcsample.pdb"
SubSystem="2"
ImportLibrary=""
ImportLibrary="../../../../win32\vc8\libd/mfcsample.lib"
TargetMachine="1"
/>
<Tool
@@ -118,7 +118,7 @@
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="../../../../win32\vc8\lib"
OutputDirectory="../../../../win32\vc8\bin"
IntermediateDirectory=".\win32\obj"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -180,13 +180,13 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win32\vc8\lib/mfcsample.dll"
OutputFile="../../../../win32\vc8\bin/mfcsample.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB32)"
ProgramDatabaseFile="../../../../win32\vc8\lib/mfcsample.pdb"
ProgramDatabaseFile="../../../../win32\vc8\bin/mfcsample.pdb"
SubSystem="2"
ImportLibrary=""
ImportLibrary="../../../../win32\vc8\lib/mfcsample.lib"
TargetMachine="1"
/>
<Tool
@@ -216,7 +216,7 @@
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="../../../../win64\vc8\libd"
OutputDirectory="../../../../win64\vc8\bind"
IntermediateDirectory=".\win64\objd"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -248,7 +248,7 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;$(CSF_OPT_INC)&quot;;..\..\..\..\Common"
AdditionalIncludeDirectories="$(CSF_OPT_INC),..\..\..\..\Common"
PreprocessorDefinitions="_DEBUG;WIN64;_WINDOWS;WNT;_AFXEXT;CSFDB;WINVER=0x0500"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
@@ -277,14 +277,14 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib FWOSPlugin.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win64\vc8\libd/mfcsample.dll"
OutputFile="../../../../win64\vc8\bind/mfcsample.dll"
LinkIncremental="2"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB64D)"
GenerateDebugInformation="true"
ProgramDatabaseFile="../../../../win64\vc8\libd/mfcsample.pdb"
ProgramDatabaseFile="../../../../win64\vc8\bind/mfcsample.pdb"
SubSystem="2"
ImportLibrary=""
ImportLibrary="../../../../win64\vc8\libd/mfcsample.lib"
TargetMachine="17"
/>
<Tool
@@ -314,7 +314,7 @@
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="../../../../win64\vc8\lib"
OutputDirectory="../../../../win64\vc8\bin"
IntermediateDirectory=".\win64\obj"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -376,13 +376,13 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win64\vc8\lib/mfcsample.dll"
OutputFile="../../../../win64\vc8\bin/mfcsample.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB64)"
ProgramDatabaseFile="../../../../win64\vc8\lib/mfcsample.pdb"
ProgramDatabaseFile="../../../../win64\vc8\bin/mfcsample.pdb"
SubSystem="2"
ImportLibrary=""
ImportLibrary="../../../../win64\vc8\lib/mfcsample.lib"
TargetMachine="17"
/>
<Tool

View File

@@ -21,7 +21,7 @@
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="../../../../win32\vc9\libd"
OutputDirectory="../../../../win32\vc9\bind"
IntermediateDirectory=".\win32\objd"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -82,16 +82,16 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib FWOSPlugin.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win32\vc9\libd/mfcsample.dll"
OutputFile="../../../../win32\vc9\bind/mfcsample.dll"
LinkIncremental="2"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB32D)"
GenerateDebugInformation="true"
ProgramDatabaseFile="../../../../win32\vc9\libd/mfcsample.pdb"
ProgramDatabaseFile="../../../../win32\vc9\bind/mfcsample.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=""
ImportLibrary="../../../../win32\vc9\libd/mfcsample.lib"
TargetMachine="1"
/>
<Tool
@@ -118,7 +118,7 @@
</Configuration>
<Configuration
Name="Debug|x64"
OutputDirectory="../../../../win64\vc9\libd"
OutputDirectory="../../../../win64\vc9\bind"
IntermediateDirectory=".\win64\objd"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -179,16 +179,16 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib FWOSPlugin.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win64\vc9\libd/mfcsample.dll"
OutputFile="../../../../win64\vc9\bind/mfcsample.dll"
LinkIncremental="2"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB64D)"
GenerateDebugInformation="true"
ProgramDatabaseFile="../../../../win64\vc9\libd/mfcsample.pdb"
ProgramDatabaseFile="../../../../win64\vc9\bind/mfcsample.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=""
ImportLibrary="../../../../win64\vc9\libd/mfcsample.lib"
TargetMachine="17"
/>
<Tool
@@ -215,7 +215,7 @@
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="../../../../win32\vc9\lib"
OutputDirectory="../../../../win32\vc9\bin"
IntermediateDirectory=".\win32\obj"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -277,15 +277,15 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win32\vc9\lib/mfcsample.dll"
OutputFile="../../../../win32\vc9\bin/mfcsample.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB32)"
ProgramDatabaseFile="../../../../win32\vc9\lib/mfcsample.pdb"
ProgramDatabaseFile="../../../../win32\vc9\bin/mfcsample.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=""
ImportLibrary="../../../../win32\vc9\lib/mfcsample.lib"
TargetMachine="1"
/>
<Tool
@@ -312,7 +312,7 @@
</Configuration>
<Configuration
Name="Release|x64"
OutputDirectory="../../../../win64\vc9\lib"
OutputDirectory="../../../../win64\vc9\bin"
IntermediateDirectory=".\win64\obj"
ConfigurationType="2"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
@@ -374,15 +374,15 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="TKVrml.lib TKStl.lib TKBrep.lib TKIGES.lib TKShHealing.lib TKStep.lib TKXSBase.lib TKShapeSchema.lib PTKernel.lib TKBool.lib TKCAF.lib TKCDF.lib TKernel.lib TKFeat.lib TKFillet.lib TKG2d.lib TKG3d.lib TKGeomAlgo.lib TKGeomBase.lib TKHLR.lib TKMath.lib TKOffset.lib TKPCAF.lib TKPrim.lib TKPShape.lib TKService.lib TKTopAlgo.lib TKMesh.lib TKV3d.lib TKOpenGl.lib"
OutputFile="../../../../win64\vc9\lib/mfcsample.dll"
OutputFile="../../../../win64\vc9\bin/mfcsample.dll"
LinkIncremental="1"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="$(CSF_OPT_LIB64)"
ProgramDatabaseFile="../../../../win64\vc9\lib/mfcsample.pdb"
ProgramDatabaseFile="../../../../win64\vc9\bin/mfcsample.pdb"
SubSystem="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
ImportLibrary=""
ImportLibrary="../../../../win64\vc9\lib/mfcsample.lib"
TargetMachine="17"
/>
<Tool

View File

@@ -234,8 +234,8 @@ void DocumentCommon::onTransparency()
void DocumentCommon::onDelete()
{
for ( myContext->InitCurrent(); myContext->MoreCurrent(); myContext->NextCurrent() )
myContext->Erase( myContext->Current(), false);
myContext->EraseSelected (Standard_False);
myContext->ClearSelected();
getApplication()->onSelectionChanged();
myContext->UpdateCurrentViewer();
}

View File

@@ -0,0 +1,25 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IESample", "IESample.vcxproj", "{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}.Debug|Win32.ActiveCfg = Debug|x64
{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}.Debug|x64.ActiveCfg = Debug|x64
{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}.Debug|x64.Build.0 = Debug|x64
{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}.Release|Win32.ActiveCfg = Release|x64
{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}.Release|x64.ActiveCfg = Release|x64
{AC7D6E9F-9F0B-3AFC-B2AB-D40458175F7D}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

View File

@@ -24,6 +24,10 @@ if not "%1" == "" (
set VCVER=vc11
set EXT=vcxproj
set "VCVARS=%VS110COMNTOOLS%..\..\VC\vcvarsall.bat"
) else if /I "%1" == "vc12" (
set VCVER=vc12
set EXT=vcxproj
set "VCVARS=%VS120COMNTOOLS%..\..\VC\vcvarsall.bat"
) else (
echo Error: first argument ^(%1^) should specify supported version of Visual C++,
echo one of: vc8 ^(VS 2005 SP1^), vc9 ^(VS 2008 SP1^), vc10 ^(VS 2010^) or vc11 ^(VS 2012^)

View File

@@ -418,8 +418,8 @@ Handle(TopTools_HSequenceOfShape) Translate::importBREP( const QString& file )
Handle(TopTools_HSequenceOfShape) aSequence;
TopoDS_Shape aShape;
BRep_Builder aBuilder;
Standard_Boolean result = BRepTools::Read( aShape, (Standard_CString)file.toLatin1().constData(), aBuilder );
TCollection_AsciiString aFilePath = file.toUtf8().data();
Standard_Boolean result = BRepTools::Read( aShape, aFilePath.ToCString(), aBuilder );
if ( result )
{
aSequence = new TopTools_HSequenceOfShape();
@@ -431,8 +431,10 @@ Handle(TopTools_HSequenceOfShape) Translate::importBREP( const QString& file )
Handle(TopTools_HSequenceOfShape) Translate::importIGES( const QString& file )
{
Handle(TopTools_HSequenceOfShape) aSequence;
TCollection_AsciiString aFilePath = file.toUtf8().data();
IGESControl_Reader Reader;
int status = Reader.ReadFile( (Standard_CString)file.toLatin1().constData() );
int status = Reader.ReadFile(aFilePath.ToCString() );
if ( status == IFSelect_RetDone )
{
@@ -447,9 +449,9 @@ Handle(TopTools_HSequenceOfShape) Translate::importIGES( const QString& file )
Handle(TopTools_HSequenceOfShape) Translate::importSTEP( const QString& file )
{
Handle(TopTools_HSequenceOfShape) aSequence;
TCollection_AsciiString aFilePath = file.toUtf8().data();
STEPControl_Reader aReader;
IFSelect_ReturnStatus status = aReader.ReadFile( (Standard_CString)file.toLatin1().constData() );
IFSelect_ReturnStatus status = aReader.ReadFile( aFilePath.ToCString() );
if ( status == IFSelect_RetDone )
{
//Interface_TraceFile::SetDefault();

View File

@@ -0,0 +1,25 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Tutorial", "Tutorial.vcxproj", "{E42C23CA-7A67-321E-9503-384C0FB7BA2C}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{E42C23CA-7A67-321E-9503-384C0FB7BA2C}.Debug|Win32.ActiveCfg = Debug|x64
{E42C23CA-7A67-321E-9503-384C0FB7BA2C}.Debug|x64.ActiveCfg = Debug|x64
{E42C23CA-7A67-321E-9503-384C0FB7BA2C}.Debug|x64.Build.0 = Debug|x64
{E42C23CA-7A67-321E-9503-384C0FB7BA2C}.Release|Win32.ActiveCfg = Release|x64
{E42C23CA-7A67-321E-9503-384C0FB7BA2C}.Release|x64.ActiveCfg = Release|x64
{E42C23CA-7A67-321E-9503-384C0FB7BA2C}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

View File

@@ -24,6 +24,10 @@ if not "%1" == "" (
set VCVER=vc11
set EXT=vcxproj
set "VCVARS=%VS110COMNTOOLS%..\..\VC\vcvarsall.bat"
) else if /I "%1" == "vc12" (
set VCVER=vc12
set EXT=vcxproj
set "VCVARS=%VS120COMNTOOLS%..\..\VC\vcvarsall.bat"
) else (
echo Error: first argument ^(%1^) should specify supported version of Visual C++,
echo one of: vc8 ^(VS 2005 SP1^), vc9 ^(VS 2008 SP1^), vc10 ^(VS 2010^) or vc11 ^(VS 2012^)

View File

@@ -0,0 +1,26 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VoxelDemo", "VoxelDemo.vcxproj", "{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}.Debug|Win32.ActiveCfg = Debug|x64
{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}.Debug|x64.ActiveCfg = Debug|x64
{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}.Debug|x64.Build.0 = Debug|x64
{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}.Release|Win32.ActiveCfg = Release|x64
{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}.Release|x64.ActiveCfg = Release|x64
{59F93AA4-FBAD-3468-B4E7-2D6290D2D461}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

View File

@@ -79,6 +79,11 @@ win32 {
OBJECTS_DIR = ./win32/vc11/objd
MOC_DIR = ./win32/vc11/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1800) {
DESTDIR = ./win32/vc12/bind
OBJECTS_DIR = ./win32/vc12/objd
MOC_DIR = ./win32/vc12/srcd
}
} else {
LIBS = -L$(CSF_OPT_LIB64D)
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1400) {
@@ -101,6 +106,11 @@ win32 {
OBJECTS_DIR = ./win64/vc11/objd
MOC_DIR = ./win64/vc11/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1800) {
DESTDIR = ./win64/vc12/bind
OBJECTS_DIR = ./win64/vc12/objd
MOC_DIR = ./win64/vc12/srcd
}
}
} else {
DEFINES += NDEBUG
@@ -131,6 +141,11 @@ win32 {
OBJECTS_DIR = ./win32/vc11/obj
MOC_DIR = ./win32/vc11/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1800) {
DESTDIR = ./win32/vc12/bin
OBJECTS_DIR = ./win32/vc12/obj
MOC_DIR = ./win32/vc12/src
}
} else {
LIBS = -L$(CSF_OPT_LIB64)
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1400) {
@@ -153,6 +168,11 @@ win32 {
OBJECTS_DIR = ./win64/vc11/obj
MOC_DIR = ./win64/vc11/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1800) {
DESTDIR = ./win64/vc12/bin
OBJECTS_DIR = ./win64/vc12/obj
MOC_DIR = ./win64/vc12/src
}
}
}
DEFINES +=WNT WIN32 NO_COMMONSAMPLE_EXPORTS NO_IESAMPLE_EXPORTS

View File

@@ -1,290 +0,0 @@
<?xml version="1.0" encoding="windows-1251"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="VoxelDemo"
ProjectGUID="{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}"
RootNamespace="VoxelDemo"
Keyword="Win32Proj"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".\inc;$(CSF_OPT_INC)"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;WNT"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="opengl32.lib glu32.lib TKernel.lib TKMath.lib TKGeomBase.lib TKV3d.lib TKService.lib TKG3d.lib TKVoxel.lib TKTopAlgo.lib TKBRep.lib TKPrim.lib TKOpenGl.lib vfw32.lib QtCore4.lib QtGui4.lib "
LinkIncremental="2"
AdditionalLibraryDirectories="$(CSF_OPT_LIB32D)"
GenerateDebugInformation="true"
SubSystem="1"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="$(CSF_OPT_INC);.\inc"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;WNT"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="opengl32.lib glu32.lib TKernel.lib TKMath.lib TKGeomBase.lib TKV3d.lib TKService.lib TKG3d.lib TKVoxel.lib TKTopAlgo.lib TKBRep.lib TKPrim.lib TKOpenGl.lib vfw32.lib QtCore4.lib QtGui4.lib "
LinkIncremental="1"
AdditionalLibraryDirectories="$(CSF_OPT_LIB32)"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\src\Application.cpp"
>
</File>
<File
RelativePath=".\src\ConversionThread.cpp"
>
</File>
<File
RelativePath=".\src\Main.cpp"
>
</File>
<File
RelativePath=".\src\Timer.cpp"
>
</File>
<File
RelativePath=".\src\Viewer.cpp"
>
</File>
<File
RelativePath=".\src\VoxelClient_VisDrawer.cxx"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\inc\Application.h"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCustomBuildTool"
CommandLine="moc.exe inc\$(InputFileName) -o moc\moc_$(InputName).cpp&#x0D;&#x0A;"
Outputs="moc\moc_$(InputName).cpp"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCustomBuildTool"
CommandLine="moc.exe inc\$(InputFileName) -o moc\moc_$(InputName).cpp&#x0D;&#x0A;"
Outputs="moc\moc_$(InputName).cpp"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\inc\ConversionThread.h"
>
</File>
<File
RelativePath=".\inc\Timer.h"
>
</File>
<File
RelativePath=".\inc\Viewer.h"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCustomBuildTool"
CommandLine="moc.exe inc\$(InputFileName) -o moc\moc_$(InputName).cpp&#x0D;&#x0A;"
Outputs="moc\moc_$(InputName).cpp"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCustomBuildTool"
CommandLine="moc.exe inc\$(InputFileName) -o moc\moc_$(InputName).cpp&#x0D;&#x0A;"
Outputs="moc\moc_$(InputName).cpp"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\inc\VoxelClient_VisDrawer.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
<Filter
Name="moc"
>
<File
RelativePath=".\moc\moc_Application.cpp"
>
</File>
<File
RelativePath=".\moc\moc_Viewer.cpp"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

View File

@@ -1,128 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}</ProjectGuid>
<RootNamespace>VoxelDemo</RootNamespace>
<Keyword>Win32Proj</Keyword>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>Unicode</CharacterSet>
<WholeProgramOptimization>true</WholeProgramOptimization>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Configuration)\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Configuration)\</OutDir>
<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Configuration)\</IntDir>
<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>.\inc;$(CSF_OPT_INC);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;WNT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalDependencies>opengl32.lib;glu32.lib;TKernel.lib;TKMath.lib;TKGeomBase.lib;TKV3d.lib;TKService.lib;TKG3d.lib;TKVoxel.lib;TKTopAlgo.lib;TKBRep.lib;TKPrim.lib;TKOpenGl.lib;vfw32.lib;QtCore4.lib;QtGui4.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32D);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
<DataExecutionPrevention>
</DataExecutionPrevention>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<AdditionalIncludeDirectories>$(CSF_OPT_INC);.\inc;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;WNT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalDependencies>opengl32.lib;glu32.lib;TKernel.lib;TKMath.lib;TKGeomBase.lib;TKV3d.lib;TKService.lib;TKG3d.lib;TKVoxel.lib;TKTopAlgo.lib;TKBRep.lib;TKPrim.lib;TKOpenGl.lib;vfw32.lib;QtCore4.lib;QtGui4.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(CSF_OPT_LIB32);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<GenerateDebugInformation>true</GenerateDebugInformation>
<SubSystem>Console</SubSystem>
<OptimizeReferences>true</OptimizeReferences>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
<DataExecutionPrevention>
</DataExecutionPrevention>
<TargetMachine>MachineX86</TargetMachine>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="src\Application.cpp" />
<ClCompile Include="src\ConversionThread.cpp" />
<ClCompile Include="src\Main.cpp" />
<ClCompile Include="src\Timer.cpp" />
<ClCompile Include="src\Viewer.cpp" />
<ClCompile Include="src\VoxelClient_VisDrawer.cxx" />
<ClCompile Include="moc\moc_Application.cpp" />
<ClCompile Include="moc\moc_Viewer.cpp" />
</ItemGroup>
<ItemGroup>
<CustomBuild Include="inc\Application.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">moc.exe inc\%(Filename)%(Extension) -o moc\moc_%(Filename).cpp
</Command>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">moc.exe inc\%(Filename)%(Extension) -o moc\moc_%(Filename).cpp
</Command>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="inc\ConversionThread.h" />
<ClInclude Include="inc\Timer.h" />
<CustomBuild Include="inc\Viewer.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">moc.exe inc\%(Filename)%(Extension) -o moc\moc_%(Filename).cpp
</Command>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">moc.exe inc\%(Filename)%(Extension) -o moc\moc_%(Filename).cpp
</Command>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="inc\VoxelClient_VisDrawer.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

View File

@@ -0,0 +1,43 @@
REM Generation of vcproj files with qmake utilite
REM Variable QTDIR and PATH to qmake executable must be defined without fail
REM Use first argument to specify version of Visual Studio (vc8, vc9, or vc10),
REM second argument specifies architecture) (win32 or win64)
REM third argument specifies Debug or Release mode
call "%~dp0../../../env.bat" %1 %2 %3
set EXT=vcxproj
if not "%1" == "" (
if /I "%1" == "vc8" (
set VCVER=vc8
set "VCVARS=%VS80COMNTOOLS%..\..\VC\vcvarsall.bat"
) else if /I "%1" == "vc9" (
set VCVER=vc9
set "VCVARS=%VS90COMNTOOLS%..\..\VC\vcvarsall.bat"
) else if /I "%1" == "vc10" (
set VCVER=vc10
set EXT=vcxproj
set "VCVARS=%VS100COMNTOOLS%..\..\VC\vcvarsall.bat"
) else if /I "%1" == "vc11" (
set VCVER=vc11
set EXT=vcxproj
set "VCVARS=%VS110COMNTOOLS%..\..\VC\vcvarsall.bat"
) else if /I "%1" == "vc12" (
set VCVER=vc12
set EXT=vcxproj
set "VCVARS=%VS120COMNTOOLS%..\..\VC\vcvarsall.bat"
) else (
echo Error: first argument ^(%1^) should specify supported version of Visual C++,
echo one of: vc8 ^(VS 2005 SP1^), vc9 ^(VS 2008 SP1^), vc10 ^(VS 2010^) or vc11 ^(VS 2012^)
exit
)
)
if ["%ARCH%"] == ["32"] set VCARCH=x86
if ["%ARCH%"] == ["64"] set VCARCH=amd64
call "%VCVARS%" %VCARCH%
qmake -tp vc -o VoxelDemo.%EXT% VoxelDemo.pro

View File

@@ -1,10 +1,12 @@
# Creation of 2d drawing
#Category: Modeling
#Title: Snowflake - creation of 2d geometry
#Category: Modeling
#Title: Snowflake - creation of 2d drawing
pload MODELING AISV
puts "Generating sample drawing of snowflake..."
# make circular elements
circle c11 5 5 0 5
circle c12 5 5 0 3
@@ -121,10 +123,22 @@ eval compound [explode scale w] scale
eval compound [explode mass w] mass
compound sample occ name material sheets scale mass text
compound snowflake frame text drawing
compound snowflake lines text drawing
# display in 3d view
vinit Driver1/Viewer1/View1 w=1024 h=768
vdisplay snowflake lines text
vsetcolor snowflake 0 0 0
vsetcolor lines 0 0 0
vsetcolor text 0 0 0
vsetcolorbg 255 255 255
vtop
vfit
vfit
# add dimension
explode snowflake v
vdimension length -length -shapes snowflake_93 snowflake_15 -plane xoy -value 0.001 -dispunits mm -showunits -flyout 70 -label above -color black -text 5 3d sh
if { [regexp HAVE_GL2PS [dversion]] } {
puts "You can use command vexport to generate PDF: vexport your_file_path.pdf"
}

View File

@@ -428,8 +428,8 @@ is
-- Removes selection mode from Interactive Objects.
-- aMode provides the selection mode index of the entity aniobj.
SetPixelTolerance(me:mutable;
aPrecision: Real from Standard = 2.0);
SetPixelTolerance (me:mutable;
aPrecision: Integer from Standard = 2);
---Level: Public
---Purpose: Disables the mechanism of adaptive tolerance calculation in SelectMgr_ViewerSelector and
-- sets the given tolerance for ALL sensitive entities activated. For more information, see
@@ -437,12 +437,20 @@ is
-- Warning: When a local context is open the sensitivity is apply on it
-- instead on the main context.
PixelTolerance(me) returns Real from Standard;
PixelTolerance(me) returns Integer from Standard;
---Level: Public
---Purpose: Returns the pixel tolerance.
---Category: put locations on objects....
--
--
SetSelectionSensitivity (me : mutable;
theObject : InteractiveObject from AIS;
theMode : Integer from Standard;
theNewSensitivity : Integer from Standard);
---Purpose: Allows to manage sensitivity of a particular selection of interactive object theObject and
-- changes previous sensitivity value of all sensitive entities in selection with theMode to
-- the given theNewSensitivity.
SetLocation(me:mutable;
aniobj : InteractiveObject from AIS;
@@ -1942,6 +1950,16 @@ is
ClearActiveSensitive(me:mutable;aView:View from V3d) is static;
FitSelected (me : mutable;
theView : View from V3d;
theMargin : Real from Standard = 0.01;
theToUpdate : Boolean from Standard = Standard_True)
is static;
---Level: Public
---Purpose: Fits the view correspondingly to the bounds of selected objects.
-- Infinite objects are ignored if infinite state of AIS_InteractiveObject
-- is set to true.
DisplayActiveSensitive(me:mutable;

View File

@@ -68,6 +68,9 @@ namespace
return TCollection_AsciiString ("AIS_CurContext_")
+ TCollection_AsciiString (Standard_Atomic_Increment (&THE_AIS_INDEX_CUR));
}
typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_IndexedMapOfOwner)> AIS_MapOfObjectOwners;
typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_IndexedMapOfOwner)>::Iterator AIS_MapIteratorOfMapOfObjectOwners;
}
//=======================================================================
@@ -698,11 +701,16 @@ void AIS_InteractiveContext::EraseSelected (const Standard_Boolean theToUpdateVi
Standard_Boolean isFound = Standard_False;
Handle(AIS_Selection) aSelIter = AIS_Selection::Selection(myCurrentName.ToCString());
for (aSelIter->Init(); aSelIter->More(); aSelIter->Next())
aSelIter->Init();
while (aSelIter->More())
{
Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter->Value());
Erase (anObj, Standard_False);
isFound = Standard_True;
aSelIter->Init();
}
if (isFound && theToUpdateViewer)
@@ -2330,9 +2338,16 @@ void AIS_InteractiveContext::EraseGlobal (const Handle(AIS_InteractiveObject)& t
for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
{
if (myMainPM->IsHighlighted (theIObj, aDispModeIter.Value()))
if (aStatus->IsHilighted())
{
myMainPM->Unhighlight (theIObj, aDispModeIter.Value());
if (IsCurrent (theIObj))
{
AddOrRemoveCurrentObject (theIObj, Standard_False);
}
else if (myMainPM->IsHighlighted (theIObj, aDispModeIter.Value()))
{
myMainPM->Unhighlight (theIObj, aDispModeIter.Value());
}
}
myMainPM->SetVisibility (theIObj, aDispModeIter.Value(), Standard_False);
@@ -2596,7 +2611,7 @@ void AIS_InteractiveContext::UnsetSelectionMode (const Handle(AIS_InteractiveObj
// sensitive entities activated. For more information, see
// SelectMgr_ViewerSelector.hxx
//=======================================================================
void AIS_InteractiveContext::SetPixelTolerance (const Standard_Real thePrecision)
void AIS_InteractiveContext::SetPixelTolerance (const Standard_Integer thePrecision)
{
if (HasOpenedContext())
{
@@ -2612,13 +2627,30 @@ void AIS_InteractiveContext::SetPixelTolerance (const Standard_Real thePrecision
//function : PixelTolerance
//purpose :
//=======================================================================
Standard_Real AIS_InteractiveContext::PixelTolerance() const
Standard_Integer AIS_InteractiveContext::PixelTolerance() const
{
return HasOpenedContext()
? myLocalContexts (myCurLocalIndex)->PixelTolerance()
: myMainSel->PixelTolerance();
}
//=======================================================================
//function : SetSelectionSensitivity
//purpose : Allows to manage sensitivity of a particular selection of interactive object theObject
//=======================================================================
void AIS_InteractiveContext::SetSelectionSensitivity (const Handle(AIS_InteractiveObject)& theObject,
const Standard_Integer theMode,
const Standard_Integer theNewSensitivity)
{
if (HasOpenedContext())
{
myLocalContexts (myCurLocalIndex)->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
return;
}
mgrSelector->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
}
//=======================================================================
//function : IsInLocal
//purpose :
@@ -2677,7 +2709,7 @@ void AIS_InteractiveContext::InitAttributes()
aLineAspect->SetTypeOfLine (Aspect_TOL_DASH);
// tolerance to 2 pixels...
SetPixelTolerance (2.0);
SetPixelTolerance (2);
// Customizing the drawer for trihedrons and planes...
Handle(Prs3d_DatumAspect) aTrihAspect = myDefaultDrawer->DatumAspect();
@@ -2824,3 +2856,65 @@ void AIS_InteractiveContext::Disconnect (const Handle(AIS_InteractiveObject)& th
else
return;
}
//=======================================================================
//function : FitSelected
//purpose : Fits the view corresponding to the bounds of selected objects
//=======================================================================
void AIS_InteractiveContext::FitSelected (const Handle(V3d_View)& theView,
const Standard_Real theMargin,
const Standard_Boolean theToUpdate)
{
Standard_CString aSelName = HasOpenedContext() ?
myLocalContexts (myCurLocalIndex)->SelectionName().ToCString()
: myCurrentName.ToCString();
Bnd_Box aBndSelected;
const Handle(AIS_Selection)& aSelection = AIS_Selection::Selection (aSelName);
AIS_MapOfObjectOwners anObjectOwnerMap;
for (aSelection->Init(); aSelection->More(); aSelection->Next())
{
const Handle(AIS_InteractiveObject)& anObj =
Handle(AIS_InteractiveObject)::DownCast (aSelection->Value());
if (!anObj.IsNull())
{
if (anObj->IsInfinite())
continue;
Bnd_Box aTmpBnd;
anObj->BoundingBox (aTmpBnd);
aBndSelected.Add (aTmpBnd);
}
else
{
const Handle(SelectMgr_EntityOwner)& anOwner =
Handle(SelectMgr_EntityOwner)::DownCast (aSelection->Value());
if (anOwner.IsNull())
continue;
Handle(SelectMgr_IndexedMapOfOwner) anOwnerMap;
if (!anObjectOwnerMap.Find (anOwner->Selectable(), anOwnerMap))
{
anOwnerMap = new SelectMgr_IndexedMapOfOwner();
anObjectOwnerMap.Bind (anOwner->Selectable(), anOwnerMap);
}
anOwnerMap->Add (anOwner);
}
}
for (AIS_MapIteratorOfMapOfObjectOwners anIter (anObjectOwnerMap); anIter.More(); anIter.Next())
{
const Handle(SelectMgr_SelectableObject) anObject = anIter.Key();
Bnd_Box aTmpBox = anObject->BndBoxOfSelected (anIter.ChangeValue());
aBndSelected.Add (aTmpBox);
}
anObjectOwnerMap.Clear();
if (aBndSelected.IsVoid())
return;
theView->FitAll (aBndSelected, theMargin, theToUpdate);
}

View File

@@ -1079,7 +1079,7 @@ Handle(SelectMgr_EntityOwner) AIS_InteractiveContext::SelectedOwner() const
//function : EntityOwners
//purpose :
//=======================================================================
void AIS_InteractiveContext::EntityOwners(SelectMgr_IndexedMapOfOwner& theOwners,
void AIS_InteractiveContext::EntityOwners(Handle(SelectMgr_IndexedMapOfOwner)& theOwners,
const Handle(AIS_InteractiveObject)& theIObj,
const Standard_Integer theMode) const
{
@@ -1092,6 +1092,9 @@ void AIS_InteractiveContext::EntityOwners(SelectMgr_IndexedMapOfOwner& theOwners
else
aModes.Append( theMode );
if (theOwners.IsNull())
theOwners = new SelectMgr_IndexedMapOfOwner();
TColStd_ListIteratorOfListOfInteger anItr( aModes );
for (; anItr.More(); anItr.Next() )
{
@@ -1110,7 +1113,7 @@ void AIS_InteractiveContext::EntityOwners(SelectMgr_IndexedMapOfOwner& theOwners
Handle(SelectMgr_EntityOwner) aOwner =
Handle(SelectMgr_EntityOwner)::DownCast(aEntity->OwnerId());
if ( !aOwner.IsNull() )
theOwners.Add( aOwner );
theOwners->Add( aOwner );
}
}
}

View File

@@ -437,16 +437,24 @@ is
HiCol : out NameOfColor from Quantity)
returns Boolean from Standard;
SetPixelTolerance(me:mutable;
aPrecision: Real from Standard = 2);
SetPixelTolerance (me:mutable;
aPrecision: Integer from Standard = 2);
---Level: Public
---Purpose: Define the current selection sensitivity for
-- this local context according to the view size.
PixelTolerance(me) returns Real from Standard;
PixelTolerance(me) returns Integer from Standard;
---Level: Public
---Purpose: Returns the pixel tolerance.
SetSelectionSensitivity (me : mutable;
theObject : InteractiveObject from AIS;
theMode : Integer from Standard;
theNewSensitivity : Integer from Standard);
---Purpose: Allows to manage sensitivity of a particular selection of interactive object theObject and
-- changes previous sensitivity value of all sensitive entities in selection with theMode to
-- the given theNewSensitivity.
---Category: IMMEDIATE MODE

View File

@@ -74,6 +74,7 @@ mySM(aCtx->SelectionManager()),
myMainVS(aCtx->MainSelector()),
myFilters(new SelectMgr_OrFilter()),
myAutoHilight(Standard_True),
myMapOfOwner (new SelectMgr_IndexedMapOfOwner()),
mylastindex(0),
mylastgood(0),
myCurDetected(0),
@@ -606,7 +607,7 @@ void AIS_LocalContext::Terminate (const Standard_Boolean theToUpdate)
{
ClearDetected();
Clear();
myMapOfOwner.Clear();
myMapOfOwner->Clear();
mylastindex=0;
// clear the selector...
@@ -1050,16 +1051,16 @@ HasFilters(const TopAbs_ShapeEnum aType) const
void AIS_LocalContext::ClearDetected()
{
for(Standard_Integer I=1;I<=myMapOfOwner.Extent();I++)
for(Standard_Integer I=1;I<=myMapOfOwner->Extent();I++)
{
if(!myMapOfOwner(I).IsNull())
if(!myMapOfOwner->FindKey (I).IsNull())
{
if(myMapOfOwner(I)->IsHilighted(myMainPM))
myMapOfOwner(I)->Unhilight(myMainPM);
if(myMapOfOwner->FindKey (I)->IsHilighted(myMainPM))
myMapOfOwner->FindKey (I)->Unhilight(myMainPM);
else
{
const Handle(SelectMgr_SelectableObject)& SO =
myMapOfOwner.FindKey(I)->Selectable();
myMapOfOwner->FindKey (I)->Selectable();
if(myActiveObjects.IsBound(SO))
{
const Handle(AIS_LocalStatus)& Att = myActiveObjects(SO);
@@ -1068,7 +1069,7 @@ void AIS_LocalContext::ClearDetected()
Att->DisplayMode()==-1 &&
Att->SelectionModes().IsEmpty())
{
myMapOfOwner(I)->Clear(myMainPM);
myMapOfOwner->FindKey (I)->Clear(myMainPM);
}
}
}
@@ -1139,12 +1140,23 @@ Standard_Boolean AIS_LocalContext::IsImmediateModeOn() const
return myMainPM->IsImmediateModeOn();
}
void AIS_LocalContext::SetPixelTolerance(const Standard_Real aPrecision) {
void AIS_LocalContext::SetPixelTolerance(const Standard_Integer aPrecision) {
myMainVS->SetPixelTolerance(aPrecision);
}
Standard_Real AIS_LocalContext::PixelTolerance() const {
Standard_Integer AIS_LocalContext::PixelTolerance() const {
return myMainVS->PixelTolerance();
}
//=======================================================================
//function : SetSelectionSensitivity
//purpose : Allows to manage sensitivity of a particular selection of interactive object theObject
//=======================================================================
void AIS_LocalContext::SetSelectionSensitivity (const Handle(AIS_InteractiveObject)& theObject,
const Standard_Integer theMode,
const Standard_Integer theNewSensitivity)
{
mySM->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
}

View File

@@ -61,4 +61,4 @@ inline Standard_Boolean AIS_LocalContext::HasNextDetected() const
{return myCurDetected<myDetectedSeq.Length();}
inline Standard_Boolean AIS_LocalContext::IsValidIndex(const Standard_Integer indx) const
{ return (indx>0 && indx<=myMapOfOwner.Extent());}
{ return (indx>0 && indx<=myMapOfOwner->Extent());}

View File

@@ -95,10 +95,10 @@ AIS_StatusOfDetection AIS_LocalContext::MoveTo (const Standard_Integer theXpix,
// result of courses..
if (aDetectedNb == 0 || myDetectedSeq.IsEmpty())
{
if (mylastindex != 0 && mylastindex <= myMapOfOwner.Extent())
if (mylastindex != 0 && mylastindex <= myMapOfOwner->Extent())
{
myMainPM->ClearImmediateDraw();
Unhilight (myMapOfOwner (mylastindex), theView);
Unhilight (myMapOfOwner->FindKey (mylastindex), theView);
if (theToRedrawImmediate)
{
theView->RedrawImmediate();
@@ -148,7 +148,7 @@ AIS_StatusOfPick AIS_LocalContext::Select (const Standard_Boolean toUpdateViewer
return (AIS_Selection::Extent() == 0) ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
}
const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner (aDetIndex);
const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner->FindKey (aDetIndex);
ClearSelected (Standard_False);
@@ -314,7 +314,7 @@ AIS_StatusOfPick AIS_LocalContext::ShiftSelect (const Standard_Boolean toUpdateV
{
AIS_Selection::SetCurrentSelection (mySelName.ToCString());
Standard_Integer aSelNum = AIS_Selection::Extent();
const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner (aDetIndex);
const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner->FindKey (aDetIndex);
Standard_Boolean toSelect = anOwner->IsSelected() ? Standard_False : Standard_True;
AIS_Selection::Select (anOwner);
anOwner->SetSelected (toSelect);
@@ -940,9 +940,9 @@ void AIS_LocalContext::ClearOutdatedSelection (const Handle(AIS_InteractiveObjec
// 4. AIS_LocalContext - myMapOfOwner : remove entity owners from myMapOfOwner
SelectMgr_IndexedMapOfOwner anOwnersToKeep;
for (Standard_Integer anIdx = 1; anIdx <= myMapOfOwner.Extent(); anIdx++)
for (Standard_Integer anIdx = 1; anIdx <= myMapOfOwner->Extent(); anIdx++)
{
Handle(SelectMgr_EntityOwner) anOwner = myMapOfOwner (anIdx);
Handle(SelectMgr_EntityOwner) anOwner = myMapOfOwner->FindKey (anIdx);
if (anOwner.IsNull())
{
continue;
@@ -960,9 +960,9 @@ void AIS_LocalContext::ClearOutdatedSelection (const Handle(AIS_InteractiveObjec
}
}
}
myMapOfOwner.Clear();
myMapOfOwner.Assign (anOwnersToKeep);
mylastindex = myMapOfOwner.FindIndex (aLastPicked);
myMapOfOwner->Clear();
myMapOfOwner->Assign (anOwnersToKeep);
mylastindex = myMapOfOwner->FindIndex (aLastPicked);
if (!IsValidIndex (mylastindex))
{
myMainPM->ClearImmediateDraw();
@@ -1159,9 +1159,9 @@ void AIS_LocalContext::manageDetected (const Handle(SelectMgr_EntityOwner)& theP
//
//=======================================================================================================
const Standard_Integer aNewIndex = myMapOfOwner.Contains (thePickOwner)
? myMapOfOwner.FindIndex (thePickOwner)
: myMapOfOwner.Add (thePickOwner);
const Standard_Integer aNewIndex = myMapOfOwner->Contains (thePickOwner)
? myMapOfOwner->FindIndex (thePickOwner)
: myMapOfOwner->Add (thePickOwner);
// For the advanced mesh selection mode the owner indices comparison
// is not effective because in that case only one owner manage the
@@ -1173,9 +1173,9 @@ void AIS_LocalContext::manageDetected (const Handle(SelectMgr_EntityOwner)& theP
{
myMainPM->ClearImmediateDraw();
if (mylastindex != 0
&& mylastindex <= myMapOfOwner.Extent())
&& mylastindex <= myMapOfOwner->Extent())
{
const Handle(SelectMgr_EntityOwner)& aLastOwner = myMapOfOwner (mylastindex);
const Handle(SelectMgr_EntityOwner)& aLastOwner = myMapOfOwner->FindKey (mylastindex);
Unhilight (aLastOwner, theView);
}
@@ -1222,7 +1222,7 @@ AIS_LocalContext::DetectedShape() const
static TopoDS_Shape bidsh;
if(mylastindex != 0)
{
Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(myMapOfOwner(mylastindex));
Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(myMapOfOwner->FindKey (mylastindex));
if(BROwnr.IsNull()) return bidsh;
return BROwnr->Shape();
}
@@ -1239,7 +1239,7 @@ AIS_LocalContext::DetectedInteractive() const
{
Handle(AIS_InteractiveObject) Iobj;
if(IsValidIndex(mylastindex)){
Handle(SelectMgr_SelectableObject) SO = myMapOfOwner.FindKey(mylastindex)->Selectable();
Handle(SelectMgr_SelectableObject) SO = myMapOfOwner->FindKey(mylastindex)->Selectable();
Iobj = *((Handle(AIS_InteractiveObject)*) &SO);
}
return Iobj;
@@ -1252,7 +1252,7 @@ Handle(SelectMgr_EntityOwner) AIS_LocalContext::DetectedOwner() const
{
Handle(SelectMgr_EntityOwner) bid;
if(!IsValidIndex(mylastindex)) return bid;
return myMapOfOwner.FindKey(mylastindex);
return myMapOfOwner->FindKey(mylastindex);
}
@@ -1263,7 +1263,7 @@ Handle(SelectMgr_EntityOwner) AIS_LocalContext::DetectedOwner() const
Standard_Boolean AIS_LocalContext::ComesFromDecomposition(const Standard_Integer PickedIndex) const
{
const Handle(SelectMgr_EntityOwner)& OWN = myMapOfOwner.FindKey(PickedIndex);
const Handle(SelectMgr_EntityOwner)& OWN = myMapOfOwner->FindKey(PickedIndex);
Handle(SelectMgr_SelectableObject) aSel = OWN->Selectable();
if (myActiveObjects.IsBound (aSel)) { // debug of jmi
const Handle(AIS_LocalStatus)& Stat = myActiveObjects(aSel);
@@ -1300,7 +1300,7 @@ void AIS_LocalContext::ClearSensitive(const Handle(V3d_View)& aviou)
Standard_Boolean AIS_LocalContext::IsShape(const Standard_Integer Index) const
{
if(Handle(StdSelect_BRepOwner)::DownCast(myMapOfOwner.FindKey(Index)).IsNull())
if(Handle(StdSelect_BRepOwner)::DownCast(myMapOfOwner->FindKey(Index)).IsNull())
return Standard_False;
return
ComesFromDecomposition(Index);
@@ -1383,12 +1383,12 @@ Standard_Boolean AIS_LocalContext::UnhilightLastDetected (const Handle(V3d_View)
}
myMainPM->BeginImmediateDraw();
const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner (mylastindex);
const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner->FindKey (mylastindex);
const Standard_Integer aHilightMode = anOwner->HasSelectable()
? GetHiMod (Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable()))
: 0;
myMapOfOwner (mylastindex)->Unhilight (myMainPM, aHilightMode);
myMapOfOwner->FindKey (mylastindex)->Unhilight (myMainPM, aHilightMode);
myMainPM->EndImmediateDraw (theView);
mylastindex = 0;
return Standard_True;
@@ -1454,8 +1454,10 @@ Handle(SelectMgr_EntityOwner) AIS_LocalContext::FindSelectedOwnerFromShape(const
Standard_Boolean found(Standard_False);
if (!found) {
NCollection_List<Handle(SelectBasics_EntityOwner)>::Iterator anOwnersIt (myMainVS->ActiveOwners());
for (; anOwnersIt.More(); anOwnersIt.Next()) {
NCollection_List<Handle(SelectBasics_EntityOwner)> anActiveOwners;
myMainVS->ActiveOwners (anActiveOwners);
for (NCollection_List<Handle(SelectBasics_EntityOwner)>::Iterator anOwnersIt (anActiveOwners); anOwnersIt.More(); anOwnersIt.Next())
{
EO = Handle(SelectMgr_EntityOwner)::DownCast (anOwnersIt.Value());
Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(EO);
if (!BROwnr.IsNull() && BROwnr->HasShape() && BROwnr->Shape() == sh) {

View File

@@ -474,10 +474,30 @@ void AIS_Shape::setColor (const Handle(Prs3d_Drawer)& theDrawer,
*theDrawer->PointAspect()->Aspect() = *theDrawer->Link()->PointAspect()->Aspect();
}
}
// disable dedicated line aspects
theDrawer->SetFreeBoundaryAspect (theDrawer->LineAspect());
theDrawer->SetUnFreeBoundaryAspect(theDrawer->LineAspect());
theDrawer->SetSeenLineAspect (theDrawer->LineAspect());
if (!theDrawer->HasOwnFreeBoundaryAspect())
{
theDrawer->SetFreeBoundaryAspect (new Prs3d_LineAspect (Quantity_NOC_BLACK, Aspect_TOL_SOLID, 1.0));
if (theDrawer->HasLink())
{
*theDrawer->FreeBoundaryAspect()->Aspect() = *theDrawer->Link()->FreeBoundaryAspect()->Aspect();
}
}
if (!theDrawer->HasOwnUnFreeBoundaryAspect())
{
theDrawer->SetUnFreeBoundaryAspect (new Prs3d_LineAspect (Quantity_NOC_BLACK, Aspect_TOL_SOLID, 1.0));
if (theDrawer->HasLink())
{
*theDrawer->UnFreeBoundaryAspect()->Aspect() = *theDrawer->Link()->UnFreeBoundaryAspect()->Aspect();
}
}
if (!theDrawer->HasOwnSeenLineAspect())
{
theDrawer->SetSeenLineAspect (new Prs3d_LineAspect (Quantity_NOC_BLACK, Aspect_TOL_SOLID, 1.0));
if (theDrawer->HasLink())
{
*theDrawer->SeenLineAspect()->Aspect() = *theDrawer->Link()->SeenLineAspect()->Aspect();
}
}
// override color
theDrawer->ShadingAspect()->SetColor (theColor, myCurrentFacingModel);
@@ -485,6 +505,9 @@ void AIS_Shape::setColor (const Handle(Prs3d_Drawer)& theDrawer,
theDrawer->LineAspect()->SetColor (theColor);
theDrawer->WireAspect()->SetColor (theColor);
theDrawer->PointAspect()->SetColor (theColor);
theDrawer->FreeBoundaryAspect()->SetColor (theColor);
theDrawer->UnFreeBoundaryAspect()->SetColor (theColor);
theDrawer->SeenLineAspect()->SetColor (theColor);
}
//=======================================================================
@@ -695,14 +718,37 @@ void AIS_Shape::setWidth (const Handle(Prs3d_Drawer)& theDrawer,
*theDrawer->WireAspect()->Aspect() = *theDrawer->Link()->WireAspect()->Aspect();
}
}
// disable dedicated line aspects
theDrawer->SetFreeBoundaryAspect (theDrawer->LineAspect());
theDrawer->SetUnFreeBoundaryAspect(theDrawer->LineAspect());
theDrawer->SetSeenLineAspect (theDrawer->LineAspect());
if (!theDrawer->HasOwnFreeBoundaryAspect())
{
theDrawer->SetFreeBoundaryAspect (new Prs3d_LineAspect (Quantity_NOC_BLACK, Aspect_TOL_SOLID, 1.0));
if (theDrawer->HasLink())
{
*theDrawer->FreeBoundaryAspect()->Aspect() = *theDrawer->Link()->FreeBoundaryAspect()->Aspect();
}
}
if (!theDrawer->HasOwnUnFreeBoundaryAspect())
{
theDrawer->SetUnFreeBoundaryAspect (new Prs3d_LineAspect (Quantity_NOC_BLACK, Aspect_TOL_SOLID, 1.0));
if (theDrawer->HasLink())
{
*theDrawer->UnFreeBoundaryAspect()->Aspect() = *theDrawer->Link()->UnFreeBoundaryAspect()->Aspect();
}
}
if (!theDrawer->HasOwnSeenLineAspect())
{
theDrawer->SetSeenLineAspect (new Prs3d_LineAspect (Quantity_NOC_BLACK, Aspect_TOL_SOLID, 1.0));
if (theDrawer->HasLink())
{
*theDrawer->SeenLineAspect()->Aspect() = *theDrawer->Link()->SeenLineAspect()->Aspect();
}
}
// override width
theDrawer->LineAspect()->SetWidth (theLineWidth);
theDrawer->WireAspect()->SetWidth (theLineWidth);
theDrawer->FreeBoundaryAspect()->SetWidth (theLineWidth);
theDrawer->UnFreeBoundaryAspect()->SetWidth (theLineWidth);
theDrawer->SeenLineAspect()->SetWidth (theLineWidth);
}
//=======================================================================

View File

@@ -766,14 +766,15 @@ gp_Circ Adaptor3d_IsoCurve::Circle() const
case GeomAbs_SurfaceOfRevolution:
{
if (myIso == GeomAbs_IsoV) {
gp_Ax1 Ax1 = mySurface->AxeOfRevolution();
gp_Vec DX(Ax1.Location(), Value(0));
if(DX.IsParallel(Ax1.Direction(),Precision::Angular())) {
return gp_Circ(gp_Ax2(Value(0), Ax1.Direction()),0);
const gp_Pnt aVal0 = Value (0.0);
gp_Ax1 Ax1 = mySurface->AxeOfRevolution();
if (gp_Lin (Ax1).Contains (aVal0, Precision::Confusion())) {
return gp_Circ(gp_Ax2(aVal0, Ax1.Direction()),0);
}
else {
gp_Vec DX(Ax1.Location(), aVal0);
axes = gp_Ax3(Ax1.Location(), Ax1.Direction(), DX);
computeHR(axes,Value(0),h,radius);
computeHR(axes,aVal0,h,radius);
gp_Vec VT = axes.Direction();
axes.Translate(VT * h);
return gp_Circ(axes.Ax2(),radius);

View File

@@ -14,6 +14,31 @@
#include <BOPAlgo_ArgumentAnalyzer.ixx>
#include <BOPAlgo_ArgumentAnalyzer.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPAlgo_CheckerSI.hxx>
#include <BOPAlgo_Operation.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_SequenceOfShape.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_MapOfPassKey.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BRep_Builder.hxx>
#include <BRep_TEdge.hxx>
#include <BRep_TFace.hxx>
#include <BRep_Tool.hxx>
#include <BRep_TVertex.hxx>
#include <BRepExtrema_DistShapeShape.hxx>
#include <Geom_Surface.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_CommonPrt.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_EdgeEdge.hxx>
#include <IntTools_Range.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
@@ -30,18 +55,6 @@
#include <TopoDS_Wire.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Solid.hxx>
#include <BRep_TVertex.hxx>
#include <BRep_TEdge.hxx>
#include <BRep_TFace.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BRepExtrema_DistShapeShape.hxx>
//
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_SequenceOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
@@ -63,6 +76,8 @@
#include <BOPAlgo_CheckerSI.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <TopExp_Explorer.hxx>
// ================================================================================
// function: Constructor
// purpose:
@@ -825,10 +840,9 @@ void BOPAlgo_ArgumentAnalyzer::TestMergeEdge()
// ================================================================================
void BOPAlgo_ArgumentAnalyzer::TestContinuity()
{
Standard_Integer i;
Standard_Integer i, j, aNbS;
Standard_Real f, l;
TopExp_Explorer aExp;
BOPCol_MapIteratorOfMapOfShape aIt;
//
for (i = 0; i < 2; ++i) {
const TopoDS_Shape& aS = !i ? myShape1 : myShape2;
@@ -836,7 +850,7 @@ void BOPAlgo_ArgumentAnalyzer::TestContinuity()
continue;
}
//
BOPCol_MapOfShape aMS;
BOPCol_IndexedMapOfShape aMS;
//Edges
aExp.Init(aS, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
@@ -860,9 +874,9 @@ void BOPAlgo_ArgumentAnalyzer::TestContinuity()
}
//
//add shapes with continuity C0 to result
aIt.Initialize(aMS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aFS = aIt.Value();
aNbS = aMS.Extent();
for (j = 1; j <= aNbS; ++j) {
const TopoDS_Shape& aFS = aMS(j);
BOPAlgo_CheckResult aResult;
if(i == 0) {
aResult.SetShape1(myShape1);

View File

@@ -38,21 +38,17 @@
#include <BOPAlgo_BuilderSolid.hxx>
#include <BRep_Tool.hxx>
#include <NCollection_IncAllocator.hxx>
//
#include <BOPTools_Set.hxx>
#include <BOPTools_SetMapHasher.hxx>
#include <NCollection_DataMap.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
typedef NCollection_DataMap
<BOPTools_Set,
TopoDS_Shape,
BOPTools_SetMapHasher> BOPTools_DataMapOfSetShape;
typedef NCollection_IndexedDataMap
<BOPTools_Set,
TopoDS_Shape,
BOPTools_SetMapHasher> BOPTools_IndexedDataMapOfSetShape;
//
typedef BOPTools_DataMapOfSetShape::Iterator
BOPTools_DataMapIteratorOfDataMapOfSetShape;
static
TopAbs_ShapeEnum TypeToExplore(const Standard_Integer theDim);
@@ -364,7 +360,8 @@ void BOPAlgo_BOP::Perform()
}
}
//
aAllocator=new NCollection_IncAllocator;
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_ListOfShape aLS(aAllocator);
//
aItLS.Initialize(myArguments);
@@ -535,7 +532,7 @@ void BOPAlgo_BOP::BuildRC()
BOPCol_ListIteratorOfListOfShape aItLS, aItIm;
Standard_Boolean bHasInterf;
Standard_Integer iX;
BOPTools_DataMapOfSetShape aDMSTS;
BOPTools_IndexedDataMapOfSetShape aDMSTS;
//
myErrorStatus=0;
//
@@ -595,7 +592,7 @@ void BOPAlgo_BOP::BuildRC()
//
aST.Add(aSIm, TopAbs_FACE);
//
aDMSTS.Bind(aST, aSIm);
aDMSTS.Add(aST, aSIm);
}
}
}
@@ -660,8 +657,8 @@ void BOPAlgo_BOP::BuildRC()
//
aST.Add(aSIm, TopAbs_FACE);
//
if (aDMSTS.IsBound(aST)) {
const TopoDS_Shape& aSImA=aDMSTS.Find(aST);
if (aDMSTS.Contains(aST)) {
const TopoDS_Shape& aSImA=aDMSTS.FindFromKey(aST);
aBB.Add(aC, aSImA);
}
}
@@ -674,7 +671,7 @@ void BOPAlgo_BOP::BuildRC()
//
aST.Add(aSIm, TopAbs_FACE);
//
bIsBound=aDMSTS.IsBound(aST);
bIsBound=aDMSTS.Contains(aST);
}
//
if (!bIsBound) {
@@ -841,8 +838,7 @@ void BOPAlgo_BOP::BuildSolid()
BOPCol_ListOfShape aSFS;
BOPAlgo_BuilderSolid aSB;
BOPCol_MapOfShape aMSA, aMZ;
BOPTools_DataMapOfSetShape aDMSTS;
BOPTools_DataMapIteratorOfDataMapOfSetShape aItDMSTS;
BOPTools_IndexedDataMapOfSetShape aDMSTS;
//
myErrorStatus=0;
//
@@ -898,8 +894,8 @@ void BOPAlgo_BOP::BuildSolid()
//
aST.Add(aSx, TopAbs_FACE);
//
if (!aDMSTS.IsBound(aST)) {
aDMSTS.Bind(aST, aSx);
if (!aDMSTS.Contains(aST)) {
aDMSTS.Add(aST, aSx);
}
continue;
@@ -996,9 +992,9 @@ void BOPAlgo_BOP::BuildSolid()
aBB.Add(aRC, aSR);
}
//
aItDMSTS.Initialize(aDMSTS);
for (; aItDMSTS.More(); aItDMSTS.Next()) {
const TopoDS_Shape& aSx=aItDMSTS.Value();
aNbSx = aDMSTS.Extent();
for (i = 1; i <= aNbSx; ++i) {
const TopoDS_Shape& aSx = aDMSTS(i);
aBB.Add(aRC, aSx);
}
//

View File

@@ -20,8 +20,6 @@
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <NCollection_IncAllocator.hxx>
#include <TopoDS_Compound.hxx>
#include <BRep_Builder.hxx>
@@ -267,7 +265,8 @@ void BOPAlgo_Builder::Perform()
}
}
//
Handle(NCollection_BaseAllocator) aAllocator=new NCollection_IncAllocator;
Handle(NCollection_BaseAllocator) aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPAlgo_PaveFiller* pPF=new BOPAlgo_PaveFiller(aAllocator);
//

View File

@@ -25,7 +25,7 @@ uses
Shape from TopoDS,
BaseAllocator from BOPCol,
ListOfShape from BOPCol,
MapOfOrientedShape from BOPCol,
IndexedMapOfOrientedShape from BOPCol,
Context from IntTools
--raises
@@ -73,7 +73,7 @@ fields
myLoopsInternal : ListOfShape from BOPCol is protected;
myAreas : ListOfShape from BOPCol is protected;
myShapesToAvoid : MapOfOrientedShape from BOPCol is protected;
myShapesToAvoid : IndexedMapOfOrientedShape from BOPCol is protected;
end BuilderArea;

View File

@@ -16,16 +16,25 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BOPAlgo_BuilderFace.ixx>
//
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_DataMap.hxx>
//
#include <TColStd_MapIntegerHasher.hxx>
//
#include <gp_Pnt2d.hxx>
#include <gp_Pln.hxx>
#include <gp_Vec.hxx>
#include <Bnd_Box.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPAlgo_WireEdgeSet.hxx>
#include <BOPAlgo_WireSplitter.hxx>
#include <BOPCol_Box2DBndTree.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_MapOfOrientedShape.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
#include <BRepTools.hxx>
#include <Geom_Surface.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
//
@@ -58,18 +67,8 @@
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BOPAlgo_WireEdgeSet.hxx>
#include <NCollection_UBTreeFiller.hxx>
//
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPTools.hxx>
#include <BOPCol_ListOfShape.hxx>
//
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_Box2DBndTree.hxx>
//
#include <BOPAlgo_WireSplitter.hxx>
static
Standard_Boolean IsGrowthWire(const TopoDS_Shape& ,
const BOPCol_IndexedMapOfShape& );
@@ -79,7 +78,7 @@ static
const TopoDS_Shape& ,
Handle(IntTools_Context)& );
static
void MakeInternalWires(const BOPCol_MapOfShape& ,
void MakeInternalWires(const BOPCol_IndexedMapOfShape& ,
BOPCol_ListOfShape& );
static
void GetWire(const TopoDS_Shape& ,
@@ -132,8 +131,7 @@ class BOPAlgo_ShapeBox2D {
//
typedef NCollection_IndexedDataMap
<Standard_Integer,
BOPAlgo_ShapeBox2D,
TColStd_MapIntegerHasher> BOPAlgo_IndexedDataMapOfIntegerShapeBox2D;
BOPAlgo_ShapeBox2D> BOPAlgo_IndexedDataMapOfIntegerShapeBox2D;
typedef NCollection_IndexedDataMap
<TopoDS_Shape,
@@ -333,9 +331,8 @@ void BOPAlgo_BuilderFace::PerformLoops()
myErrorStatus=0;
//
Standard_Boolean bFlag;
Standard_Integer iErr, aNbEA;
Standard_Integer i, iErr, aNbEA;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_MapIteratorOfMapOfOrientedShape aItM;
BOPCol_IndexedDataMapOfShapeListOfShape aVEMap;
BOPCol_MapOfOrientedShape aMAdded;
TopoDS_Iterator aItW;
@@ -384,9 +381,9 @@ void BOPAlgo_BuilderFace::PerformLoops()
}
//
// b. collect all edges that are to avoid
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aE=aItM.Key();
aNbEA = myShapesToAvoid.Extent();
for (i = 1; i <= aNbEA; ++i) {
const TopoDS_Shape& aE = myShapesToAvoid(i);
aMEP.Add(aE);
}
//
@@ -402,10 +399,9 @@ void BOPAlgo_BuilderFace::PerformLoops()
// 2. Internal Wires
myLoopsInternal.Clear();
//
aNbEA=myShapesToAvoid.Extent();
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aEE=aItM.Key();
aNbEA = myShapesToAvoid.Extent();
for (i = 1; i <= aNbEA; ++i) {
const TopoDS_Shape& aEE = myShapesToAvoid(i);
BOPTools::MapShapesAndAncestors(aEE,
TopAbs_VERTEX,
TopAbs_EDGE,
@@ -413,9 +409,8 @@ void BOPAlgo_BuilderFace::PerformLoops()
}
//
bFlag=Standard_True;
aItM.Initialize(myShapesToAvoid);
for (; aItM.More()&&bFlag; aItM.Next()) {
const TopoDS_Shape& aEE=aItM.Key();
for (i = 1; (i <= aNbEA) && bFlag; ++i) {
const TopoDS_Shape& aEE = myShapesToAvoid(i);
if (!aMAdded.Add(aEE)) {
continue;
}
@@ -445,8 +440,9 @@ void BOPAlgo_BuilderFace::PerformLoops()
}//for (; aIt.More(); aIt.Next()) {
}//for (; aItE.More(); aItE.Next()) {
}//for (; aItW.More(); aItW.Next()) {
aW.Closed(BRep_Tool::IsClosed(aW));
myLoopsInternal.Append(aW);
}//for (; aItM.More(); aItM.Next()) {
}//for (i = 1; (i <= aNbEA) && bFlag; ++i) {
}
//=======================================================================
//function : PerformAreas
@@ -705,11 +701,11 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
}
//
//Standard_Real aTol;
Standard_Integer i;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aIt1, aIt2;
TopoDS_Iterator aIt;
BOPCol_MapOfShape aME, aMEP;
BOPCol_MapIteratorOfMapOfShape aItME;
BOPCol_IndexedMapOfShape aME1, aME2, aMEP;
BOPCol_IndexedDataMapOfShapeListOfShape aMVE;
BOPCol_ListOfShape aLSI;
//
@@ -720,10 +716,9 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
aIt.Initialize(aWire);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
aME.Add(aE);
aME1.Add(aE);
}
}
aNbWI=aME.Extent();
//
// 2 Process faces
aIt2.Initialize(myAreas);
@@ -734,13 +729,17 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
BOPTools::MapShapesAndAncestors(aF, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
//
// 2.1 Separate faces to process aMEP
aME2.Clear();
aMEP.Clear();
aItME.Initialize(aME);
for (; aItME.More(); aItME.Next()) {
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aItME.Key()));
aNbWI = aME1.Extent();
for (i = 1; i <= aNbWI; ++i) {
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&aME1(i)));
if (IsInside(aE, aF, myContext)) {
aMEP.Add(aE);
}
else {
aME2.Add(aE);
}
}
//
// 2.2 Make Internal Wires
@@ -755,13 +754,9 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
}
//
// 2.4 Remove faces aMFP from aMF
aItME.Initialize(aMEP);
for (; aItME.More(); aItME.Next()) {
const TopoDS_Shape& aE=aItME.Key();
aME.Remove(aE);
}
aME1 = aME2;
//
aNbWI=aME.Extent();
aNbWI = aME1.Extent();
if (!aNbWI) {
break;
}
@@ -771,24 +766,23 @@ void BOPAlgo_BuilderFace::PerformInternalShapes()
//function : MakeInternalWires
//purpose :
//=======================================================================
void MakeInternalWires(const BOPCol_MapOfShape& theME,
void MakeInternalWires(const BOPCol_IndexedMapOfShape& theME,
BOPCol_ListOfShape& theWires)
{
BOPCol_MapIteratorOfMapOfShape aItM;
Standard_Integer i, aNbE;
BOPCol_MapOfShape aAddedMap;
BOPCol_ListIteratorOfListOfShape aItE;
BOPCol_IndexedDataMapOfShapeListOfShape aMVE;
BRep_Builder aBB;
//
aItM.Initialize(theME);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aE=aItM.Key();
aNbE = theME.Extent();
for (i = 1; i <= aNbE; ++i) {
const TopoDS_Shape& aE = theME(i);
BOPTools::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
}
//
aItM.Initialize(theME);
for (; aItM.More(); aItM.Next()) {
TopoDS_Shape aEE=aItM.Key();
for (i = 1; i <= aNbE; ++i) {
TopoDS_Shape aEE = theME(i);
if (!aAddedMap.Add(aEE)) {
continue;
}
@@ -817,6 +811,7 @@ void MakeInternalWires(const BOPCol_MapOfShape& theME,
}
}
}
aW.Closed(BRep_Tool::IsClosed(aW));
theWires.Append(aW);
}
}

View File

@@ -20,7 +20,6 @@
#include <NCollection_List.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_IncAllocator.hxx>
//
#include <gp_Pnt2d.hxx>
#include <gp_Pln.hxx>
@@ -47,34 +46,29 @@
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
//
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
//
#include <BRepBndLib.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
//
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfOrientedShape.hxx>
#include <BOPCol_DataMapOfShapeShape.hxx>
#include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <Precision.hxx>
#include <IntTools_Context.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <BOPAlgo_ShellSplitter.hxx>
#include <BOPCol_BoxBndTree.hxx>
#include <BOPCol_MapOfOrientedShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeShape.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
//
#include <BOPTools.hxx>
#include <BOPTools_CoupleOfShape.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
//
#include <IntTools_Context.hxx>
//
#include <BOPAlgo_ShellSplitter.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools.hxx>
#include <BRepBndLib.hxx>
#include <Bnd_Box.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
#include <TopExp_Explorer.hxx>
//
static
Standard_Boolean IsGrowthShell(const TopoDS_Shape& ,
const BOPCol_IndexedMapOfShape& );
@@ -86,7 +80,7 @@ static
const TopoDS_Shape& ,
Handle(IntTools_Context)& );
static
void MakeInternalShells(const BOPCol_MapOfShape& ,
void MakeInternalShells(const BOPCol_IndexedMapOfShape& ,
BOPCol_ListOfShape& );
//=======================================================================
@@ -261,14 +255,7 @@ typedef BOPCol_ContextCnt
Handle(IntTools_Context)> BOPAlgo_FaceSolidCnt;
//
//=======================================================================
typedef NCollection_DataMap
<TopoDS_Shape,
gp_Pnt,
TopTools_ShapeMapHasher> BOPAlgo_DataMapOfShapePnt;
typedef BOPAlgo_DataMapOfShapePnt::Iterator
BOPAlgo_DataMapIteratorOfDataMapOfShapePnt;
//
//=======================================================================
//function :
//purpose :
@@ -448,16 +435,16 @@ void BOPAlgo_BuilderSolid::PerformShapesToAvoid()
//=======================================================================
void BOPAlgo_BuilderSolid::PerformLoops()
{
Standard_Integer iErr;
Standard_Integer iErr, i, aNbSh;
BOPCol_ListIteratorOfListOfShape aIt;
TopoDS_Iterator aItS;
BOPCol_MapIteratorOfMapOfOrientedShape aItM;
Handle(NCollection_BaseAllocator) aAlr;
//
myErrorStatus=0;
myLoops.Clear();
//
aAlr=new NCollection_IncAllocator();
aAlr=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPAlgo_ShellSplitter aSSp(aAlr);
//
// 1. Shells Usual
@@ -512,9 +499,9 @@ void BOPAlgo_BuilderSolid::PerformLoops()
}
//
// b. collect all edges that are to avoid
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aF=aItM.Key();
aNbSh = myShapesToAvoid.Extent();
for (i = 1; i <= aNbSh; ++i) {
const TopoDS_Shape& aF = myShapesToAvoid(i);
aMP.Add(aF);
}
//
@@ -536,17 +523,16 @@ void BOPAlgo_BuilderSolid::PerformLoops()
aEFMap.Clear();
AddedFacesMap.Clear();
//
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aFF=aItM.Key();
aNbSh = myShapesToAvoid.Extent();
for (i = 1; i <= aNbSh; ++i) {
const TopoDS_Shape& aFF = myShapesToAvoid(i);
BOPTools::MapShapesAndAncestors(aFF,
TopAbs_EDGE, TopAbs_FACE,
aEFMap);
}
//
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aFF=aItM.Key();
for (i = 1; i <= aNbSh; ++i) {
const TopoDS_Shape& aFF = myShapesToAvoid(i);
if (!AddedFacesMap.Add(aFF)) {
continue;
}
@@ -585,11 +571,11 @@ void BOPAlgo_BuilderSolid::PerformLoops()
void BOPAlgo_BuilderSolid::PerformAreas()
{
Standard_Boolean bIsGrowth, bIsHole;
Standard_Integer k;
Standard_Integer i, k, aNbInOut, aNbMSH;
BRep_Builder aBB;
BOPCol_ListIteratorOfListOfShape aItLS;
BOPCol_ListOfShape aNewSolids, aHoleShells;
BOPCol_DataMapOfShapeShape aInOutMap;
BOPCol_IndexedDataMapOfShapeShape aInOutMap;
BOPCol_IndexedMapOfShape aMHF;
BOPCol_ListIteratorOfListOfInteger aItLI;
BOPCol_BoxBndTreeSelector aSelector;
@@ -597,10 +583,8 @@ void BOPAlgo_BuilderSolid::PerformAreas()
NCollection_UBTreeFiller
<Standard_Integer, Bnd_Box> aTreeFiller(aBBTree);
BOPAlgo_DataMapOfIntegerBSSB aDMISB(100);
BOPCol_IndexedDataMapOfShapeListOfShape aMSH;
BOPAlgo_DataMapIteratorOfDataMapOfIntegerBSSB aItDMISB;
BOPCol_DataMapOfShapeListOfShape aMSH;
BOPCol_DataMapIteratorOfDataMapOfShapeShape aItDMSS;
BOPCol_DataMapIteratorOfDataMapOfShapeListOfShape aItMSH;
//
myErrorStatus=0;
//
@@ -698,42 +682,41 @@ void BOPAlgo_BuilderSolid::PerformAreas()
continue;
}
//
if (aInOutMap.IsBound (aHole)){
const TopoDS_Shape& aSolidWas=aInOutMap(aHole);
if (aInOutMap.Contains (aHole)){
const TopoDS_Shape& aSolidWas = aInOutMap.FindFromKey(aHole);
if (IsInside(aSolid, aSolidWas, myContext)) {
aInOutMap.UnBind(aHole);
aInOutMap.Bind (aHole, aSolid);
aInOutMap.ChangeFromKey(aHole) = aSolid;
}
}
else{
aInOutMap.Bind(aHole, aSolid);
aInOutMap.Add(aHole, aSolid);
}
}
}//for (; aItDMISB.More(); aItDMISB.Next()) {
}//for (i = 1; i <= aNbDMISB; ++i) {
//
// 5. Map [Solid/Holes] -> aMSH
aItDMSS.Initialize(aInOutMap);
for (; aItDMSS.More(); aItDMSS.Next()) {
const TopoDS_Shape& aHole=aItDMSS.Key();
const TopoDS_Shape& aSolid=aItDMSS.Value();
aNbInOut = aInOutMap.Extent();
for (i = 1; i <= aNbInOut; ++i) {
const TopoDS_Shape& aHole = aInOutMap.FindKey(i);
const TopoDS_Shape& aSolid = aInOutMap(i);
//
if (aMSH.IsBound(aSolid)) {
BOPCol_ListOfShape& aLH=aMSH.ChangeFind(aSolid);
if (aMSH.Contains(aSolid)) {
BOPCol_ListOfShape& aLH = aMSH.ChangeFromKey(aSolid);
aLH.Append(aHole);
}
else {
BOPCol_ListOfShape aLH;
aLH.Append(aHole);
aMSH.Bind(aSolid, aLH);
aMSH.Add(aSolid, aLH);
}
}
//
// 6. Add aHoles to Solids
aItMSH.Initialize(aMSH);
for (; aItMSH.More(); aItMSH.Next()) {
TopoDS_Solid aSolid=(*(TopoDS_Solid*)(&aItMSH.Key()));
aNbMSH = aMSH.Extent();
for (i = 1; i <= aNbMSH; ++i) {
TopoDS_Solid aSolid=(*(TopoDS_Solid*)(&(aMSH.FindKey(i))));
const BOPCol_ListOfShape& aLH = aMSH(i);
//
const BOPCol_ListOfShape& aLH=aItMSH.Value();
aItLS.Initialize(aLH);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aHole = aItLS.Value();
@@ -758,7 +741,7 @@ void BOPAlgo_BuilderSolid::PerformAreas()
aItLS.Initialize(aHoleShells);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aHole = aItLS.Value();
if (!aInOutMap.IsBound(aHole)){
if (!aInOutMap.Contains(aHole)){
TopoDS_Solid aSolid;
//
aBB.MakeSolid(aSolid);
@@ -787,7 +770,7 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
TopoDS_Iterator aIt;
TopExp_Explorer aExp;
BOPCol_ListIteratorOfListOfShape aItLS;
BOPCol_MapOfShape aMFs;
BOPCol_IndexedMapOfShape aMFs;
BOPCol_ListOfShape aLSI;
BOPAlgo_VectorOfFaceSolid aVFS;
BOPAlgo_VectorOfFacePnt aVFP;
@@ -807,7 +790,9 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
for (; aIt.More(); aIt.Next()) {
const TopoDS_Face& aF=*((TopoDS_Face*)&aIt.Value());
//
if (aMFs.Add(aF)) {
if (!aMFs.Contains(aF)) {
aMFs.Add(aF);
//
gp_Pnt aP;
gp_Pnt2d aP2D;
//
@@ -985,27 +970,25 @@ void BOPAlgo_BuilderSolid::PerformInternalShapes()
//function : MakeInternalShells
//purpose :
//=======================================================================
void MakeInternalShells(const BOPCol_MapOfShape& theMF,
void MakeInternalShells(const BOPCol_IndexedMapOfShape& theMF,
BOPCol_ListOfShape& theShells)
{
BOPCol_ListIteratorOfListOfShape aItF;
Standard_Integer i, aNbF;
BRep_Builder aBB;
//
BOPCol_ListIteratorOfListOfShape aItF;
BOPCol_IndexedDataMapOfShapeListOfShape aMEF;
BOPCol_MapIteratorOfMapOfShape aItM;
BOPCol_MapOfShape aAddedFacesMap;
//
aItM.Initialize(theMF);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aF=aItM.Key();
aNbF = theMF.Extent();
for (i = 1; i <= aNbF; ++i) {
TopoDS_Shape aF = theMF(i);
BOPTools::MapShapesAndAncestors(aF,
TopAbs_EDGE, TopAbs_FACE,
aMEF);
}
//
aItM.Initialize(theMF);
for (; aItM.More(); aItM.Next()) {
TopoDS_Shape aFF=aItM.Key();
for (i = 1; i <= aNbF; ++i) {
TopoDS_Shape aFF = theMF(i);
if (!aAddedFacesMap.Add(aFF)) {
continue;
}

View File

@@ -34,6 +34,12 @@
#include <BOPDS_ShapeInfo.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <IntTools_Context.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
//=======================================================================
//function : FillImagesVertices
@@ -143,19 +149,19 @@
aType=aS.ShapeType();
if (aType==theType) {
if (myImages.IsBound(aS)){
const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
if (aM.Add(aSIm)) {
aBB.Add(myShape, aSIm);
}
}
const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
if (aM.Add(aSIm)) {
aBB.Add(myShape, aSIm);
}
}
}
else {
if (aM.Add(aS)) {
aBB.Add(myShape, aS);
}
if (aM.Add(aS)) {
aBB.Add(myShape, aS);
}
}
}
}
@@ -241,6 +247,8 @@
}
}
//
aCIm.Closed(BRep_Tool::IsClosed(aCIm));
//
BOPCol_ListOfShape aLSIm(myAllocator);
aLSIm.Append(aCIm);
myImages.Bind(theS, aLSIm);
@@ -288,9 +296,9 @@
const BOPCol_ListOfShape& aLFIm=myImages.Find(aSX);
aItIm.Initialize(aLFIm);
for (; aItIm.More(); aItIm.Next()) {
TopoDS_Shape aSXIm=aItIm.Value();
aSXIm.Orientation(aOrX);
aBB.Add(aCIm, aSXIm);
TopoDS_Shape aSXIm=aItIm.Value();
aSXIm.Orientation(aOrX);
aBB.Add(aCIm, aSXIm);
}
}
else {

View File

@@ -17,8 +17,6 @@
#include <BOPAlgo_Builder.ixx>
//
#include <NCollection_IncAllocator.hxx>
//
#include <TopoDS_Shape.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Edge.hxx>
@@ -68,11 +66,11 @@ static
void FillMap(const TopoDS_Shape& aS1,
const TopoDS_Shape& aS2,
BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
Handle(NCollection_IncAllocator)& aAllocator);
Handle(NCollection_BaseAllocator)& aAllocator);
static
void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
Handle(NCollection_IncAllocator)& aAllocator);
Handle(NCollection_BaseAllocator)& aAllocator);
//
typedef BOPCol_NCVector<TopoDS_Shape> BOPAlgo_VectorOfShape;
//
@@ -264,13 +262,13 @@ void BOPAlgo_Builder::BuildSplitFaces()
BOPCol_MapOfShape aMFence;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListOfShape aLFIm(myAllocator);
BOPCol_MapIteratorOfMapOfShape aItMS;
BOPAlgo_VectorOfBuilderFace aVBF;
//
myErrorStatus=0;
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope f
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfShape aLE(aAllocator);
BOPCol_MapOfShape aMDE(100, aAllocator);
@@ -444,7 +442,6 @@ void BOPAlgo_Builder::BuildSplitFaces()
mySplits.Bind(aF, aLFIm);
}// for (k=0; k<aNbBF; ++k) {
//
aAllocator.Nullify();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~scope t
}
//=======================================================================
@@ -455,7 +452,7 @@ void BOPAlgo_Builder::FillSameDomainFaces()
{
Standard_Boolean bFlag;
Standard_Integer i, j, k, aNbFFs, aNbCurves, aNbPoints, nF1, nF2, aNbS;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfShape aItF;
BOPCol_MapOfShape aMFence;
BOPAlgo_IndexedDataMapOfSetInteger aIDMSS;
@@ -604,7 +601,8 @@ void BOPAlgo_Builder::FillSameDomainFaces()
//================================================================
BOPAlgo_BuilderSDFaceCnt::Perform(myRunParallel, aVPSB, myContext);
//================================================================
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfShapeListOfShape aDMSLS(100, aAllocator);
BOPCol_DataMapOfIntegerListOfShape aMBlocks(100, aAllocator);
//
@@ -648,7 +646,6 @@ void BOPAlgo_Builder::FillSameDomainFaces()
}
aMBlocks.Clear();
aDMSLS.Clear();
aAllocator.Nullify();
}
//=======================================================================
// function: FillImagesFaces1
@@ -754,7 +751,7 @@ void BOPAlgo_Builder::FillImagesFaces1()
//=======================================================================
void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
BOPCol_DataMapOfIntegerListOfShape& aMBlocks,
Handle(NCollection_IncAllocator)& aAllocator)
Handle(NCollection_BaseAllocator)& aAllocator)
{
Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
BOPCol_ListIteratorOfListOfShape aItLI;
@@ -836,7 +833,7 @@ void MakeBlocksCnx(const BOPCol_IndexedDataMapOfShapeListOfShape& aMILI,
void FillMap(const TopoDS_Shape& aS1,
const TopoDS_Shape& aS2,
BOPCol_IndexedDataMapOfShapeListOfShape& aDMSLS,
Handle(NCollection_IncAllocator)& aAllocator)
Handle(NCollection_BaseAllocator)& aAllocator)
{
if (aDMSLS.Contains(aS1)) {
BOPCol_ListOfShape& aLS=aDMSLS.ChangeFromKey(aS1);
@@ -866,27 +863,27 @@ Standard_Boolean HasPaveBlocksOnIn(const BOPDS_FaceInfo& aFI1,
const BOPDS_FaceInfo& aFI2)
{
Standard_Boolean bRet;
BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
Standard_Integer i, aNbPB;
//
bRet=Standard_False;
const BOPDS_IndexedMapOfPaveBlock& aMPBOn1=aFI1.PaveBlocksOn();
const BOPDS_IndexedMapOfPaveBlock& aMPBIn1=aFI1.PaveBlocksIn();
const BOPDS_IndexedMapOfPaveBlock& aMPBOn1 = aFI1.PaveBlocksOn();
const BOPDS_IndexedMapOfPaveBlock& aMPBIn1 = aFI1.PaveBlocksIn();
//
const BOPDS_IndexedMapOfPaveBlock& aMPBOn2=aFI2.PaveBlocksOn();
aItMPB.Initialize(aMPBOn2);
for (; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
const BOPDS_IndexedMapOfPaveBlock& aMPBOn2 = aFI2.PaveBlocksOn();
aNbPB = aMPBOn2.Extent();
for (i = 1; i <= aNbPB; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBOn2(i);
bRet = aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
if (bRet) {
return bRet;
}
}
//
const BOPDS_IndexedMapOfPaveBlock& aMPBIn2=aFI2.PaveBlocksIn();
aItMPB.Initialize(aMPBIn2);
for (; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
bRet=aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
const BOPDS_IndexedMapOfPaveBlock& aMPBIn2 = aFI2.PaveBlocksIn();
aNbPB = aMPBIn2.Extent();
for (i = 1; i <= aNbPB; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBIn2(i);
bRet = aMPBOn1.Contains(aPB) || aMPBIn1.Contains(aPB);
if (bRet) {
return bRet;
}

View File

@@ -19,7 +19,6 @@
//
#include <Precision.hxx>
//
#include <NCollection_IncAllocator.hxx>
#include <NCollection_UBTreeFiller.hxx>
//
#include <Bnd_Box.hxx>
@@ -253,7 +252,7 @@ class BOPAlgo_FillIn3DParts : public BOPAlgo_Algo {
//=======================================================================
void BOPAlgo_FillIn3DParts::Perform()
{
Handle(NCollection_IncAllocator) aAlr1;
Handle(NCollection_BaseAllocator) aAlr1;
BOPAlgo_Algo::UserBreak();
//
Standard_Integer aNbFP, k, nFP, iIsIN;
@@ -262,7 +261,8 @@ void BOPAlgo_FillIn3DParts::Perform()
BOPCol_ListIteratorOfListOfShape aItLS;
BOPCol_BoxBndTreeSelector aSelector;
//
aAlr1=new NCollection_IncAllocator();
aAlr1=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfShape aLFP(aAlr1);
BOPCol_ListOfShape aLCBF(aAlr1);
@@ -518,10 +518,11 @@ void BOPAlgo_Builder::FillImagesSolids()
if (!bHasSolids) {
return;
}
//
Handle(NCollection_BaseAllocator) aAlr;
//
Handle(NCollection_IncAllocator) aAlr;
aAlr=NCollection_BaseAllocator::CommonBaseAllocator();
//
aAlr=new NCollection_IncAllocator();
BOPCol_DataMapOfShapeListOfShape theInParts(100, aAlr);
BOPCol_DataMapOfShapeShape theDraftSolids(100, aAlr);
//
@@ -543,7 +544,7 @@ void BOPAlgo_Builder::FillIn3DParts
{
Standard_Boolean bHasImage;
Standard_Integer i, k, aNbS, aNbLIF, aNbFIN, aNbVSB, aNbVFIP;
Handle(NCollection_IncAllocator) aAlr0;
Handle(NCollection_BaseAllocator) aAlr0;
TopoDS_Solid aSD;
TopoDS_Iterator aIt;
BRep_Builder aBB;
@@ -551,7 +552,8 @@ void BOPAlgo_Builder::FillIn3DParts
BOPCol_ListIteratorOfListOfInteger aItLI, aItLI1;
BOPCol_ListIteratorOfListOfShape aItLS;
//
aAlr0=new NCollection_IncAllocator();
aAlr0=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_MapOfShape aMFence(100, aAlr0);
BOPAlgo_VectorOfShapeBox aVSB(256, aAlr0);
@@ -801,10 +803,9 @@ void BOPAlgo_Builder::BuildSplitSolids
Standard_Integer i, aNbS;
TopExp_Explorer aExp;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_DataMapIteratorOfDataMapOfShapeShape aIt1;
//
Handle(NCollection_IncAllocator) aAlr0;
aAlr0=new NCollection_IncAllocator();
Handle(NCollection_BaseAllocator) aAlr0;
aAlr0=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfShape aSFS(aAlr0), aLSEmpty(aAlr0);
BOPCol_MapOfShape aMFence(100, aAlr0);
@@ -870,10 +871,7 @@ void BOPAlgo_Builder::BuildSplitSolids
aSFS.Append(aF);
}
//
// 1.3 Build new solids
Handle(NCollection_IncAllocator) aAlr1;
aAlr1=new NCollection_IncAllocator();
//
// 1.3 Build new solids
BOPAlgo_BuilderSolid& aBS=aVBS.Append1();
aBS.SetSolid(aSolid);
aBS.SetShapes(aSFS);
@@ -933,21 +931,21 @@ void BOPAlgo_Builder::FillInternalShapes()
TopAbs_State aState;
TopoDS_Iterator aItS;
BRep_Builder aBB;
BOPCol_MapIteratorOfMapOfShape aItM;
BOPCol_ListIteratorOfListOfShape aIt, aIt1;
//
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
//-----------------------------------------------------scope f
aAllocator=new NCollection_IncAllocator();
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_IndexedDataMapOfShapeListOfShape aMSx(100, aAllocator);
BOPCol_IndexedMapOfShape aMx(100, aAllocator);
BOPCol_MapOfShape aMSI(100, aAllocator);
BOPCol_IndexedMapOfShape aMSI(100, aAllocator);
BOPCol_MapOfShape aMFence(100, aAllocator);
BOPCol_MapOfShape aMSOr(100, aAllocator);
BOPCol_ListOfShape aLSd(aAllocator);
BOPCol_ListOfShape aLArgs(aAllocator);
BOPCol_ListOfShape aLSC(aAllocator);
BOPCol_ListOfShape aLSI(aAllocator);
//
// 1. Shapes to process
//
@@ -1066,20 +1064,23 @@ void BOPAlgo_Builder::FillInternalShapes()
//
// 3. Some shapes of aMSI can be already tied with faces of
// split solids
aItM.Initialize(aMSI);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aSI=aItM.Key();
aNbSI = aMSI.Extent();
for (i = 1; i <= aNbSI; ++i) {
const TopoDS_Shape& aSI = aMSI(i);
if (aMSx.Contains(aSI)) {
const BOPCol_ListOfShape &aLSx=aMSx.FindFromKey(aSI);
aNbSx=aLSx.Extent();
if (aNbSx) {
aMSI.Remove(aSI);
aNbSx = aLSx.Extent();
if (!aNbSx) {
aLSI.Append(aSI);
}
}
else {
aLSI.Append(aSI);
}
}
//
// 4. Just check it
aNbSI=aMSI.Extent();
aNbSI = aLSI.Extent();
if (!aNbSI) {
return;
}
@@ -1090,49 +1091,52 @@ void BOPAlgo_Builder::FillInternalShapes()
for (; aIt.More(); aIt.Next()) {
TopoDS_Solid aSd=TopoDS::Solid(aIt.Value());
//
aItM.Initialize(aMSI);
for (; aItM.More(); aItM.Next()) {
TopoDS_Shape aSI=aItM.Key();
aIt1.Initialize(aLSI);
for (; aIt1.More();) {
TopoDS_Shape aSI = aIt1.Value();
aSI.Orientation(TopAbs_INTERNAL);
//
aState=BOPTools_AlgoTools::ComputeStateByOnePoint
(aSI, aSd, 1.e-11, myContext);
if (aState==TopAbs_IN) {
//
if (aState != TopAbs_IN) {
aIt1.Next();
continue;
}
//
if(aMSOr.Contains(aSd)) {
//
if(aMSOr.Contains(aSd)) {
//
TopoDS_Solid aSdx;
//
aBB.MakeSolid(aSdx);
aItS.Initialize(aSd);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aSh=aItS.Value();
aBB.Add(aSdx, aSh);
}
//
aBB.Add(aSdx, aSI);
//
if (myImages.IsBound(aSdx)) {
BOPCol_ListOfShape& aLS=myImages.ChangeFind(aSdx);
aLS.Append(aSdx);
}
else {
BOPCol_ListOfShape aLS;
aLS.Append(aSdx);
myImages.Bind(aSd, aLS);
}
//
aMSOr.Remove(aSd);
aSd=aSdx;
TopoDS_Solid aSdx;
//
aBB.MakeSolid(aSdx);
aItS.Initialize(aSd);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aSh=aItS.Value();
aBB.Add(aSdx, aSh);
}
//
aBB.Add(aSdx, aSI);
//
if (myImages.IsBound(aSdx)) {
BOPCol_ListOfShape& aLS=myImages.ChangeFind(aSdx);
aLS.Append(aSdx);
}
else {
aBB.Add(aSd, aSI);
BOPCol_ListOfShape aLS;
aLS.Append(aSdx);
myImages.Bind(aSd, aLS);
}
//
aMSI.Remove(aSI);
} //if (aState==TopAbs_IN) {
}// for (; aItM.More(); aItM.Next()) {
}//for (; aIt1.More(); aIt1.Next()) {
aMSOr.Remove(aSd);
aSd=aSdx;
}
else {
aBB.Add(aSd, aSI);
}
//
aLSI.Remove(aIt1);
}//for (; aIt1.More();) {
}//for (; aIt.More(); aIt.Next()) {
//
//-----------------------------------------------------scope t
aLArgs.Clear();

View File

@@ -14,8 +14,6 @@
#include <BOPAlgo_MakerVolume.ixx>
#include <NCollection_IncAllocator.hxx>
#include <Bnd_Box.hxx>
#include <TopoDS_Solid.hxx>
@@ -81,7 +79,8 @@ void BOPAlgo_MakerVolume::Perform()
}
}
//
Handle(NCollection_BaseAllocator) aAllocator = new NCollection_IncAllocator;
Handle(NCollection_BaseAllocator) aAllocator =
NCollection_BaseAllocator::CommonBaseAllocator();
BOPAlgo_PaveFiller* pPF = new BOPAlgo_PaveFiller(aAllocator);
//
if (!myIntersect) {
@@ -244,7 +243,7 @@ void BOPAlgo_MakerVolume::MakeBox(BOPCol_MapOfShape& theBoxFaces)
//
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, anExt;
//
anExt = myBBox.SquareExtent() * 0.5;
anExt = sqrt(myBBox.SquareExtent()) * 0.5;
myBBox.Enlarge(anExt);
myBBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
//

View File

@@ -148,6 +148,10 @@ is
PerformZZ(me:out)
is virtual protected;
--Purpose: Computes Solid/Solid interferences
PerformSZ(me:out;
aTS:ShapeEnum from TopAbs)
is virtual protected;
TreatVerticesEE(me:out)
is protected;
@@ -240,7 +244,7 @@ is
theF2: Face from TopoDS;
theTolR3D:Real from Standard;
theNC:out Curve from BOPDS;
theMVB:out MapOfInteger from BOPCol)
theLBV:out ListOfInteger from BOPCol)
is protected;
IsExistingPaveBlock(me:out;
@@ -367,9 +371,9 @@ is
ProcessExistingPaveBlocks(me:out;
theInt : Integer from Standard;
theMPBOnIn : IndexedMapOfPaveBlock from BOPDS;
theDMBV : DataMapOfIntegerListOfInteger from BOPCol;
theMSCPB : out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS;
theMVI : out DataMapOfShapeInteger from BOPCol;
theMVB : MapOfInteger from BOPCol;
theMPB : out MapOfPaveBlock from BOPDS)
is protected;
---Purpose:
@@ -402,11 +406,12 @@ is
-- is closed 3D-curve
PreparePostTreatFF(me:out;
aInt : Integer from Standard;
aInt : Integer from Standard;
aCur : Integer from Standard;
aPB : PaveBlock from BOPDS;
aMSCPB : out IndexedDataMapOfShapeCoupleOfPaveBlocks from BOPDS;
aMVI : out DataMapOfShapeInteger from BOPCol;
aVC : out VectorOfCurve from BOPDS)
aLPB : out ListOfPaveBlock from BOPDS)
is protected;
---Purpose:
-- Keeps data for post treatment

View File

@@ -17,7 +17,6 @@
#include <BOPAlgo_PaveFiller.ixx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <Bnd_Box.hxx>
@@ -45,8 +44,7 @@
{
Standard_Boolean bWithSubShape;
Standard_Integer n1, n2, iFlag, nX, n, aSize, i, j, k, aNbBlocks;
Handle(NCollection_IncAllocator) aAllocator;
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItMILI;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfInteger aItLI, aItLI2;
TopoDS_Vertex aVn;
BOPDS_ShapeInfo aSIn;
@@ -65,7 +63,8 @@
aVVs.SetIncrement(aSize);
//
//-----------------------------------------------------scope f
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_IndexedDataMapOfIntegerListOfInteger aMILI(100, aAllocator);
BOPCol_DataMapOfIntegerListOfInteger aMBlocks(100, aAllocator);
BOPCol_ListOfShape aLV(aAllocator);
@@ -134,5 +133,4 @@
aLV.Clear();
aMBlocks.Clear();
aMILI.Clear();
aAllocator.Nullify();
}

View File

@@ -15,22 +15,227 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BOPAlgo_PaveFiller.ixx>
#include <gp_Pnt.hxx>
#include <TopAbs_State.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Solid.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_SectionAttribute.hxx>
#include <BOPDS_Curve.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_Interf.hxx>
#include <BOPDS_IteratorSI.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BRep_Tool.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
#include <gp_Pnt.hxx>
#include <IntTools_Context.hxx>
#include <TopAbs_State.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDS_Vertex.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_IteratorSI.hxx>
#include <BOPDS_Interf.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//class : BOPAlgo_VertexSolid
//purpose :
//=======================================================================
class BOPAlgo_VertexSolid {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_VertexSolid()
: myIV(-1), myIZ(-1), myState(TopAbs_UNKNOWN) {
};
//
virtual ~BOPAlgo_VertexSolid(){
};
//
void SetIndices(const Standard_Integer nV,
const Standard_Integer nZ){
myIV=nV;
myIZ=nZ;
}
//
void Indices(Standard_Integer& nV,
Standard_Integer& nZ) const {
nV=myIV;
nZ=myIZ;
}
//
void SetVertex(const TopoDS_Vertex& aV) {
myV=aV;
}
//
const TopoDS_Vertex& Vertex()const {
return myV;
}
//
void SetSolid(const TopoDS_Solid& aZ) {
myZ=aZ;
}
//
const TopoDS_Solid& Solid()const {
return myZ;
}
//
void SetContext(const Handle(IntTools_Context)& aContext) {
myContext=aContext;
}
//
const Handle(IntTools_Context)& Context()const {
return myContext;
}
//
TopAbs_State State() const{
return myState;
};
//
void Perform() {
Standard_Real aTol;
gp_Pnt aPV;
//
BRepClass3d_SolidClassifier& aSC=myContext->SolidClassifier(myZ);
//
aPV=BRep_Tool::Pnt(myV);
aTol=BRep_Tool::Tolerance(myV);
//
aSC.Perform(aPV, aTol);
//
myState=aSC.State();
};
//
protected:
Standard_Integer myIV;
Standard_Integer myIZ;
TopAbs_State myState;
TopoDS_Vertex myV;
TopoDS_Solid myZ;
Handle(IntTools_Context) myContext;
};
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_VertexSolid> BOPAlgo_VectorOfVertexSolid;
//
typedef BOPCol_ContextFunctor
<BOPAlgo_VertexSolid,
BOPAlgo_VectorOfVertexSolid,
Handle(IntTools_Context),
IntTools_Context> BOPAlgo_VertexSolidFunctor;
//
typedef BOPCol_ContextCnt
<BOPAlgo_VertexSolidFunctor,
BOPAlgo_VectorOfVertexSolid,
Handle(IntTools_Context)> BOPAlgo_VertexSolidCnt;
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//class : BOPAlgo_ShapeSolid
//purpose :
//=======================================================================
class BOPAlgo_ShapeSolid {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_ShapeSolid() :
myIE(-1),
myIZ(-1),
myHasInterf(Standard_False),
myDS(NULL) {
};
//
virtual ~BOPAlgo_ShapeSolid(){
};
//
void SetIndices(const Standard_Integer nE,
const Standard_Integer nZ){
myIE=nE;
myIZ=nZ;
}
//
void Indices(Standard_Integer& nE,
Standard_Integer& nZ) const {
nE=myIE;
nZ=myIZ;
}
//
void SetDS(BOPDS_DS* pDS) {
myDS=pDS;
}
//
Standard_Boolean HasInterf() const{
return myHasInterf;
};
//
virtual void Perform() {
Standard_Boolean bHasInterf;
//
myHasInterf=Standard_False;
//
bHasInterf=myDS->HasInterfShapeSubShapes(myIE, myIZ);
if (!bHasInterf) {
myHasInterf=myDS->HasInterfShapeSubShapes(myIZ, myIE);
}
};
//
protected:
Standard_Integer myIE;
Standard_Integer myIZ;
Standard_Boolean myHasInterf;
BOPDS_DS* myDS;
};
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_ShapeSolid> BOPAlgo_VectorOfShapeSolid;
//
typedef BOPCol_Functor
<BOPAlgo_ShapeSolid,
BOPAlgo_VectorOfShapeSolid> BOPAlgo_ShapeSolidFunctor;
//
typedef BOPCol_Cnt
<BOPAlgo_ShapeSolidFunctor,
BOPAlgo_VectorOfShapeSolid> BOPAlgo_ShapeSolidCnt;
//
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//class : BOPAlgo_SolidSolid
//purpose :
//=======================================================================
class BOPAlgo_SolidSolid : public BOPAlgo_ShapeSolid {
public:
DEFINE_STANDARD_ALLOC
BOPAlgo_SolidSolid() :
BOPAlgo_ShapeSolid() {
};
//
virtual ~BOPAlgo_SolidSolid(){
};
//
virtual void Perform() {
Standard_Boolean bFlag;
//
bFlag=Standard_False;
myHasInterf=Standard_False;
//
myHasInterf=myDS->HasInterfShapeSubShapes(myIZ, myIE, bFlag);
if (!myHasInterf) {
myHasInterf=myDS->HasInterfShapeSubShapes(myIE, myIZ, bFlag);
}
};
};
//=======================================================================
typedef BOPCol_NCVector
<BOPAlgo_SolidSolid> BOPAlgo_VectorOfSolidSolid;
//
typedef BOPCol_Functor
<BOPAlgo_SolidSolid,
BOPAlgo_VectorOfSolidSolid> BOPAlgo_SolidSolidFunctor;
//
typedef BOPCol_Cnt
<BOPAlgo_SolidSolidFunctor,
BOPAlgo_VectorOfSolidSolid> BOPAlgo_SolidSolidCnt;
//
/////////////////////////////////////////////////////////////////////////
//=======================================================================
//function : PerformVZ
@@ -39,9 +244,7 @@
void BOPAlgo_PaveFiller::PerformVZ()
{
Standard_Boolean bJustAdd;
Standard_Integer iSize, nV, nZ;
Standard_Real aTol;
gp_Pnt aPV;
Standard_Integer iSize, nV, nZ, k, aNbVVS;
TopAbs_State aState;
//
myErrorStatus=0;
@@ -55,6 +258,8 @@ void BOPAlgo_PaveFiller::PerformVZ()
BOPDS_VectorOfInterfVZ& aVZs=myDS->InterfVZ();
aVZs.SetIncrement(iSize);
//
BOPAlgo_VectorOfVertexSolid aVVS;
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nV, nZ, bJustAdd);
if(bJustAdd) {
@@ -67,15 +272,22 @@ void BOPAlgo_PaveFiller::PerformVZ()
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aSIV.Shape());
const TopoDS_Solid& aZ=*((TopoDS_Solid*)&aSIZ.Shape());
//
BRepClass3d_SolidClassifier& aSC=myContext->SolidClassifier(aZ);
//
aPV=BRep_Tool::Pnt(aV);
aTol=BRep_Tool::Tolerance(aV);
//
aSC.Perform(aPV, aTol);
//
aState=aSC.State();
BOPAlgo_VertexSolid& aVertexSolid=aVVS.Append1();
aVertexSolid.SetIndices(nV, nZ);
aVertexSolid.SetVertex(aV);
aVertexSolid.SetSolid(aZ);
}
//
aNbVVS=aVVS.Extent();
//=============================================================
BOPAlgo_VertexSolidCnt::Perform(myRunParallel, aVVS, myContext);
//=============================================================
for (k=0; k < aNbVVS; ++k) {
const BOPAlgo_VertexSolid& aVertexSolid=aVVS(k);
aState=aVertexSolid.State();
if (aState==TopAbs_IN) {
aVertexSolid.Indices(nV, nZ);
//
BOPDS_InterfVZ& aVZ=aVZs.Append1();
aVZ.SetIndices(nV, nZ);
//
@@ -88,84 +300,16 @@ void BOPAlgo_PaveFiller::PerformVZ()
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::PerformEZ()
{
Standard_Boolean bJustAdd, bHasInterf;
Standard_Integer iSize, nE, nZ;
//
myErrorStatus=0;
//
myIterator->Initialize(TopAbs_EDGE, TopAbs_SOLID);
iSize=myIterator->ExpectedLength();
if (!iSize) {
return;
}
//
BOPDS_VectorOfInterfEZ& aEZs=myDS->InterfEZ();
aEZs.SetIncrement(iSize);
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nE, nZ, bJustAdd);
if(bJustAdd) {
continue;
}
//
bHasInterf=myDS->HasInterfShapeSubShapes(nE, nZ);
if (bHasInterf) {
continue;
}
//
bHasInterf=myDS->HasInterfShapeSubShapes(nZ, nE);
if (!bHasInterf) {
continue;
}
//
BOPDS_InterfEZ& aEZ=aEZs.Append1();
aEZ.SetIndices(nE, nZ);
//
myDS->AddInterf(nE, nZ);
}
{
PerformSZ(TopAbs_EDGE);
}
//=======================================================================
//function : PerformFZ
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::PerformFZ()
{
Standard_Boolean bJustAdd, bHasInterf;
Standard_Integer iSize, nF, nZ;
//
myErrorStatus=0;
//
myIterator->Initialize(TopAbs_FACE, TopAbs_SOLID);
iSize=myIterator->ExpectedLength();
if (!iSize) {
return;
}
//
BOPDS_VectorOfInterfFZ& aFZs=myDS->InterfFZ();
aFZs.SetIncrement(iSize);
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nF, nZ, bJustAdd);
if(bJustAdd) {
continue;
}
//
bHasInterf=myDS->HasInterfShapeSubShapes(nF, nZ);
if (bHasInterf) {
continue;
}
//
bHasInterf=myDS->HasInterfShapeSubShapes(nZ, nF);
if (!bHasInterf) {
continue;
}
//
BOPDS_InterfFZ& aFZ=aFZs.Append1();
aFZ.SetIndices(nF, nZ);
//
myDS->AddInterf(nF, nZ);
}
{
PerformSZ(TopAbs_FACE);
}
//=======================================================================
//function : PerformZZ
@@ -173,8 +317,8 @@ void BOPAlgo_PaveFiller::PerformFZ()
//=======================================================================
void BOPAlgo_PaveFiller::PerformZZ()
{
Standard_Boolean bJustAdd, bHasInterf, bFlag;
Standard_Integer iSize, nZ1, nZ;
Standard_Boolean bJustAdd, bHasInterf;
Standard_Integer iSize, nZ1, nZ, k, aNbSolidSolid;
//
myErrorStatus=0;
//
@@ -184,10 +328,7 @@ void BOPAlgo_PaveFiller::PerformZZ()
return;
}
//
BOPDS_VectorOfInterfZZ& aZZs=myDS->InterfZZ();
aZZs.SetIncrement(iSize);
//
bFlag=Standard_False;
BOPAlgo_VectorOfSolidSolid aVSolidSolid;
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nZ1, nZ, bJustAdd);
@@ -195,17 +336,94 @@ void BOPAlgo_PaveFiller::PerformZZ()
continue;
}
//
bHasInterf=myDS->HasInterfShapeSubShapes(nZ, nZ1, bFlag);
if (!bHasInterf) {
bHasInterf=myDS->HasInterfShapeSubShapes(nZ1, nZ, bFlag);
BOPAlgo_SolidSolid& aSolidSolid=aVSolidSolid.Append1();
aSolidSolid.SetIndices(nZ1, nZ);
aSolidSolid.SetDS(myDS);
}
//
aNbSolidSolid=aVSolidSolid.Extent();
//======================================================
BOPAlgo_SolidSolidCnt::Perform(myRunParallel, aVSolidSolid);
//======================================================
//
BOPDS_VectorOfInterfZZ& aZZs=myDS->InterfZZ();
//
aZZs.SetIncrement(iSize);
//
for (k=0; k < aNbSolidSolid; ++k) {
const BOPAlgo_SolidSolid& aSolidSolid=aVSolidSolid(k);
bHasInterf=aSolidSolid.HasInterf();
if (bHasInterf) {
aSolidSolid.Indices(nZ1, nZ);
//
BOPDS_InterfZZ& aZZ=aZZs.Append1();
aZZ.SetIndices(nZ1, nZ);
//
myDS->AddInterf(nZ1, nZ);
}
}
}
//=======================================================================
//function : PerformSZ
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::PerformSZ(const TopAbs_ShapeEnum aTS)
{
Standard_Boolean bJustAdd, bHasInterf;
Standard_Integer iSize, nS, nZ, k, aNbShapeSolid;
//
myErrorStatus=0;
//
myIterator->Initialize(aTS, TopAbs_SOLID);
iSize=myIterator->ExpectedLength();
if (!iSize) {
return;
}
//
BOPAlgo_VectorOfShapeSolid aVShapeSolid;
//
for (; myIterator->More(); myIterator->Next()) {
myIterator->Value(nS, nZ, bJustAdd);
if(bJustAdd) {
continue;
}
//
BOPAlgo_ShapeSolid& aShapeSolid=aVShapeSolid.Append1();
aShapeSolid.SetIndices(nS, nZ);
aShapeSolid.SetDS(myDS);
}
//
aNbShapeSolid=aVShapeSolid.Extent();
//======================================================
BOPAlgo_ShapeSolidCnt::Perform(myRunParallel, aVShapeSolid);
//======================================================
//
BOPDS_VectorOfInterfEZ& aEZs=myDS->InterfEZ();
BOPDS_VectorOfInterfFZ& aFZs=myDS->InterfFZ();
//
if (aTS==TopAbs_EDGE) {
aEZs.SetIncrement(iSize);
}
else {//if (aTS==TopAbs_FACE)
aFZs.SetIncrement(iSize);
}
//
for (k=0; k < aNbShapeSolid; ++k) {
const BOPAlgo_ShapeSolid& aShapeSolid=aVShapeSolid(k);
bHasInterf=aShapeSolid.HasInterf();
if (bHasInterf) {
aShapeSolid.Indices(nS, nZ);
//
if (aTS==TopAbs_EDGE) {
BOPDS_InterfEZ& aEZ=aEZs.Append1();
aEZ.SetIndices(nS, nZ);
}
else {//if (aTS==TopAbs_FACE)
BOPDS_InterfFZ& aFZ=aFZs.Append1();
aFZ.SetIndices(nS, nZ);
}
//
myDS->AddInterf(nS, nZ);
}
if (!bHasInterf) {
continue;
}
//
BOPDS_InterfZZ& aZZ=aZZs.Append1();
aZZ.SetIndices(nZ1, nZ);
//
myDS->AddInterf(nZ1, nZ);
}
}

View File

@@ -18,7 +18,7 @@
#include <BOPAlgo_PaveFiller.ixx>
#include <Precision.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <Bnd_Box.hxx>
@@ -288,11 +288,12 @@ void BOPAlgo_PaveFiller::PerformEE()
Standard_Real aTS11, aTS12, aTS21, aTS22, aT11, aT12, aT21, aT22;
TopAbs_ShapeEnum aType;
BOPDS_ListIteratorOfListOfPaveBlock aIt1, aIt2;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
BOPDS_MapOfPaveBlock aMPBToUpdate;
BOPAlgo_VectorOfEdgeEdge aVEdgeEdge;
BOPDS_MapIteratorOfMapOfPaveBlock aItPB;
//
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//-----------------------------------------------------scope f
BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock aMPBLPB(100, aAllocator);
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMVCPB(100, aAllocator);
@@ -737,8 +738,7 @@ void BOPAlgo_PaveFiller::TreatNewVertices
BOPCol_IndexedMapOfShape aMVProcessed;
BOPCol_MapOfInteger aMFence;
BOPCol_ListIteratorOfListOfInteger aIt;
BOPCol_DataMapOfShapeListOfShape aDMVLV;
BOPCol_DataMapIteratorOfDataMapOfShapeListOfShape aItDMVLV;
BOPCol_IndexedDataMapOfShapeListOfShape aDMVLV;
//
BOPCol_BoxBndTreeSelector aSelector;
BOPCol_BoxBndTree aBBTree;
@@ -778,7 +778,6 @@ void BOPAlgo_PaveFiller::TreatNewVertices
//
Standard_Integer aIP, aNbIP1, aIP1;
BOPCol_ListOfShape aLVSD;
BOPCol_MapIteratorOfMapOfInteger aItMI;
BOPCol_ListOfInteger aLIP, aLIP1, aLIPC;
BOPCol_ListIteratorOfListOfInteger aItLIP;
//
@@ -823,14 +822,14 @@ void BOPAlgo_PaveFiller::TreatNewVertices
aLVSD.Append(aVP);
}
aVF=aLVSD.First();
aDMVLV.Bind(aVF, aLVSD);
aDMVLV.Add(aVF, aLVSD);
}// for (i=1; i<=aNbV; ++i) {
// Make new vertices
aItDMVLV.Initialize(aDMVLV);
for(; aItDMVLV.More(); aItDMVLV.Next()) {
const TopoDS_Shape& aV=aItDMVLV.Key();
const BOPCol_ListOfShape& aLVSD=aItDMVLV.Value();
aNbV = aDMVLV.Extent();
for (i = 1; i <= aNbV; ++i) {
const TopoDS_Shape& aV = aDMVLV.FindKey(i);
const BOPCol_ListOfShape& aLVSD = aDMVLV(i);
if (aLVSD.IsEmpty()) {
myImages.Add(aV, aLVSD);
}

View File

@@ -17,8 +17,6 @@
#include <BOPAlgo_PaveFiller.ixx>
//
#include <NCollection_IncAllocator.hxx>
//
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Face.hxx>
#include <BRep_Tool.hxx>
@@ -249,9 +247,10 @@ void BOPAlgo_PaveFiller::TreatVerticesEE()
Standard_Integer i, aNbS,aNbEEs, nF, nV, iFlag;
Standard_Real aT1, aT2;
BOPCol_ListIteratorOfListOfInteger aItLI;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
//
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPCol_ListOfInteger aLIV(aAllocator), aLIF(aAllocator);
BOPCol_MapOfInteger aMI(100, aAllocator);
BOPDS_MapOfPaveBlock aMPBF(100, aAllocator);
@@ -322,6 +321,4 @@ void BOPAlgo_PaveFiller::TreatVerticesEE()
}
}
}
//
aAllocator.Nullify();
}

View File

@@ -17,8 +17,6 @@
#include <BOPAlgo_PaveFiller.ixx>
#include <NCollection_IncAllocator.hxx>
//
#include <GeomAPI_ProjectPointOnSurf.hxx>
//
#include <Bnd_Box.hxx>
@@ -152,15 +150,15 @@ void BOPAlgo_PaveFiller::PerformEF()
Standard_Integer nE, nF, aDiscretize, i, aNbCPrts, iX, nV[2];
Standard_Integer aNbEdgeFace, k;
Standard_Real aTolE, aTolF, aTS1, aTS2, aT1, aT2, aDeflection;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
TopAbs_ShapeEnum aType;
BOPDS_ListIteratorOfListOfPaveBlock aIt;
BOPAlgo_VectorOfEdgeFace aVEdgeFace;
BRep_Builder aBB;
//-----------------------------------------------------scope f
//
////aAllocator=new NCollection_IncAllocator();
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_MapOfInteger aMIEFC(100, aAllocator);
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks aMVCPB(100, aAllocator);
BOPDS_IndexedDataMapOfPaveBlockListOfInteger aMPBLI(100, aAllocator);

View File

@@ -18,7 +18,6 @@
#include <BOPAlgo_PaveFiller.ixx>
//
#include <Precision.hxx>
#include <NCollection_IncAllocator.hxx>
#include <Bnd_Box.hxx>
#include <Geom_Curve.hxx>
@@ -65,8 +64,6 @@
#include <BOPCol_MapOfInteger.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_IndexedMapOfInteger.hxx>
#include <BOPCol_DataMapOfIntegerReal.hxx>
#include <BOPCol_NCVector.hxx>
#include <BOPCol_Parallel.hxx>
@@ -366,18 +363,19 @@ void BOPAlgo_PaveFiller::MakeBlocks()
Standard_Integer i, nF1, nF2, aNbC, aNbP, j;
Standard_Integer nV1, nV2;
Standard_Real aTolR3D, aT1, aT2, aTol;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
TopoDS_Edge aES;
Handle(BOPDS_PaveBlock) aPBOut;
//
//-----------------------------------------------------scope f
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_ListOfInteger aLSE(aAllocator);
BOPCol_ListOfInteger aLSE(aAllocator), aLBV(aAllocator);
BOPCol_MapOfInteger aMVOnIn(100, aAllocator), aMF(100, aAllocator),
aMVStick(100,aAllocator), aMVEF(100, aAllocator),
aMVB(100, aAllocator), aMI(100, aAllocator);
aMI(100, aAllocator);
BOPDS_IndexedMapOfPaveBlock aMPBOnIn(100, aAllocator);
BOPDS_MapOfPaveBlock aMPBAdd(100, aAllocator);
BOPDS_ListOfPaveBlock aLPB(aAllocator);
@@ -385,8 +383,9 @@ void BOPAlgo_PaveFiller::MakeBlocks()
BOPCol_DataMapOfShapeInteger aMVI(100, aAllocator);
BOPDS_DataMapOfPaveBlockListOfPaveBlock aDMExEdges(100, aAllocator);
BOPCol_DataMapOfIntegerReal aMVTol(100, aAllocator);
BOPCol_DataMapIteratorOfDataMapOfIntegerReal aItMV;
BOPCol_DataMapOfIntegerInteger aDMI(100, aAllocator);
BOPCol_DataMapOfIntegerListOfInteger aDMBV(100, aAllocator);
BOPCol_DataMapIteratorOfDataMapOfIntegerReal aItMV;
//
for (i=0; i<aNbFF; ++i) {
//
@@ -411,17 +410,19 @@ void BOPAlgo_PaveFiller::MakeBlocks()
// Update face info
if (aMF.Add(nF1)) {
myDS->UpdateFaceInfoOn(nF1);
myDS->UpdateFaceInfoIn(nF1);
}
if (aMF.Add(nF2)) {
myDS->UpdateFaceInfoOn(nF2);
myDS->UpdateFaceInfoIn(nF2);
}
//
BOPDS_FaceInfo& aFI1=myDS->ChangeFaceInfo(nF1);
BOPDS_FaceInfo& aFI2=myDS->ChangeFaceInfo(nF2);
//
aMVOnIn.Clear();
aMPBOnIn.Clear();
aMVB.Clear();
aDMBV.Clear();
aMVTol.Clear();
//
myDS->VerticesOnIn(nF1, nF2, aMVOnIn, aMPBOnIn);
@@ -465,7 +466,13 @@ void BOPAlgo_PaveFiller::MakeBlocks()
}
//
if (aIC.HasBounds()) {
PutBoundPaveOnCurve(aF1, aF2, aTolR3D, aNC, aMVB);
aLBV.Clear();
//
PutBoundPaveOnCurve(aF1, aF2, aTolR3D, aNC, aLBV);
//
if (!aLBV.IsEmpty()) {
aDMBV.Bind(j, aLBV);
}
}
}//for (j=0; j<aNbC; ++j) {
//
@@ -529,7 +536,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
aFI2.PaveBlocksIn().Contains(aPBOut));
}
if (!bInBothFaces) {
PreparePostTreatFF(i, aPBOut, aMSCPB, aMVI, aVC);
PreparePostTreatFF(i, j, aPBOut, aMSCPB, aMVI, aLPBC);
}
}
continue;
@@ -580,7 +587,7 @@ void BOPAlgo_PaveFiller::MakeBlocks()
TV->Tolerance(aTol);
}
//
ProcessExistingPaveBlocks(i, aMPBOnIn, aMSCPB, aMVI, aMVB, aMPBAdd);
ProcessExistingPaveBlocks(i, aMPBOnIn, aDMBV, aMSCPB, aMVI, aMPBAdd);
}//for (i=0; i<aNbFF; ++i) {
//
// post treatment
@@ -601,7 +608,6 @@ void BOPAlgo_PaveFiller::MakeBlocks()
aDMExEdges.Clear();
aMI.Clear();
aDMI.Clear();
aAllocator.Nullify();
}
//=======================================================================
@@ -913,22 +919,23 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
for (j=0; j<aNbC; ++j) {
BOPDS_Curve& aNC=aVNC(j);
BOPDS_ListOfPaveBlock& aLPBC=aNC.ChangePaveBlocks();
aItLPB.Initialize(aLPBC);
//
// Treat existing pave blocks
if (aItLPB.More() && theDME.IsBound(aLPBC.First())) {
const Handle(BOPDS_PaveBlock)& aPB=aLPBC.First();
BOPDS_ListOfPaveBlock& aLPB=theDME.ChangeFind(aPB);
UpdateExistingPaveBlocks(aPB, aLPB, nF1, nF2);
aLPBC.Clear();
continue;
}
//
// Add section edges to face info
for (; aItLPB.More(); aItLPB.Next()) {
aItLPB.Initialize(aLPBC);
for (; aItLPB.More(); ) {
const Handle(BOPDS_PaveBlock)& aPB=aItLPB.Value();
//
// Treat existing pave blocks
if (theDME.IsBound(aPB)) {
BOPDS_ListOfPaveBlock& aLPB=theDME.ChangeFind(aPB);
UpdateExistingPaveBlocks(aPB, aLPB, nF1, nF2);
aLPBC.Remove(aItLPB);
continue;
}
//
aFI1.ChangePaveBlocksSc().Add(aPB);
aFI2.ChangePaveBlocksSc().Add(aPB);
aItLPB.Next();
}
}
//
@@ -1006,6 +1013,11 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
const Handle(BOPDS_PaveBlock)& aPB = aMPBCopy(j);
if (theDME.IsBound(aPB)) {
const BOPDS_ListOfPaveBlock& aLPB = theDME.Find(aPB);
if (aLPB.IsEmpty()) {
aMPBOnIn.Add(aPB);
continue;
}
//
aItLPB.Initialize(aLPB);
for (; aItLPB.More(); aItLPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB1 = aItLPB.Value();
@@ -1189,7 +1201,7 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
const TopoDS_Face& aF2,
const Standard_Real aTolR3D,
BOPDS_Curve& aNC,
BOPCol_MapOfInteger& aMVB)
BOPCol_ListOfInteger& aLVB)
{
Standard_Boolean bVF;
Standard_Integer nV, iFlag, nVn, j, aNbEP;
@@ -1277,7 +1289,8 @@ void BOPAlgo_PaveFiller::UpdateFaceInfo
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVn);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aVn, aBoxDS);
aMVB.Add(nVn);
//
aLVB.Append(nVn);
}
}
}
@@ -1724,41 +1737,70 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
const Standard_Integer iCheckExtend)
{
Standard_Boolean bIsVertexOnLine;
Standard_Real aT, aTol, aTolNew;
BOPDS_Pave aPave;
Standard_Real aT, aTolV;
//
const TopoDS_Vertex aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
const TopoDS_Vertex& aV = (*(TopoDS_Vertex *)(&myDS->Shape(nV)));
Handle(BOPDS_PaveBlock)& aPB=aNC.ChangePaveBlock1();
const IntTools_Curve& aIC = aNC.Curve();
//
bIsVertexOnLine=myContext->IsVertexOnLine(aV, aIC, aTolR3D, aT);
if (!bIsVertexOnLine && iCheckExtend) {
aTol = BRep_Tool::Tolerance(aV);
aTolV = BRep_Tool::Tolerance(aV);
//
ExtendedTolerance(nV, aMI, aTol, iCheckExtend);
bIsVertexOnLine=myContext->IsVertexOnLine(aV, aTol, aIC, aTolR3D, aT);
ExtendedTolerance(nV, aMI, aTolV, iCheckExtend);
bIsVertexOnLine=myContext->IsVertexOnLine(aV, aTolV, aIC, aTolR3D, aT);
}
//
if (bIsVertexOnLine) {
aPave.SetIndex(nV);
aPave.SetParameter(aT);
// check if aPB contains the parameter aT
Standard_Boolean bExist;
Standard_Integer nVToUpdate;
Standard_Real aPTol, aDist, aTolVNew, aTolV2, aDTol;
TopoDS_Vertex aVToUpdate;
gp_Pnt aP1, aP2;
//
aPB->AppendExtPave(aPave);
aTolV2 = 0.;
aDTol = 1.e-12;
//
aTol = BRep_Tool::Tolerance(aV);
GeomAdaptor_Curve aGAC(aIC.Curve());
aPTol = aGAC.Resolution(aTolR3D);
//
BOPTools_AlgoTools::UpdateVertex (aIC, aT, aV);
//
if (!aMVTol.IsBound(nV)) {
aTolNew = BRep_Tool::Tolerance(aV);
if (aTolNew > aTol) {
aMVTol.Bind(nV, aTol);
}
bExist = aPB->ContainsParameter(aT, aPTol, nVToUpdate);
if (bExist) {
// use existing pave
aP1 = BRep_Tool::Pnt(aV);
aTolV2 = BRep_Tool::Tolerance(aV);
aVToUpdate = (*(TopoDS_Vertex *)(&myDS->Shape(nVToUpdate)));
}
else {
// add new pave
BOPDS_Pave aPave;
aPave.SetIndex(nV);
aPave.SetParameter(aT);
aPB->AppendExtPave(aPave);
//
aP1 = aGAC.Value(aT);
nVToUpdate = nV;
aVToUpdate = aV;
}
//
aTolV = BRep_Tool::Tolerance(aVToUpdate);
aP2 = BRep_Tool::Pnt(aVToUpdate);
aDist = aP1.Distance(aP2);
aTolVNew = aDist - aTolV2;
//
if (aTolVNew > aTolV) {
BRep_Builder aBB;
aBB.UpdateVertex(aVToUpdate, aTolVNew+aDTol);
//
if (!aMVTol.IsBound(nVToUpdate)) {
aMVTol.Bind(nVToUpdate, aTolV);
}
//
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nVToUpdate);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aVToUpdate, aBoxDS);
}
//
BOPDS_ShapeInfo& aSIDS=myDS->ChangeShapeInfo(nV);
Bnd_Box& aBoxDS=aSIDS.ChangeBox();
BRepBndLib::Add(aV, aBoxDS);
}
}
@@ -1769,51 +1811,68 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
void BOPAlgo_PaveFiller::ProcessExistingPaveBlocks
(const Standard_Integer theInt,
const BOPDS_IndexedMapOfPaveBlock& aMPBOnIn,
const BOPCol_DataMapOfIntegerListOfInteger& aDMBV,
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
BOPCol_DataMapOfShapeInteger& aMVI,
const BOPCol_MapOfInteger& aMVB,
BOPDS_MapOfPaveBlock& aMPB)
{
Standard_Integer nV, nE, iFlag, i, aNbPB;
Standard_Real aT;
BOPCol_MapIteratorOfMapOfInteger aItB;
if (aDMBV.IsEmpty()) {
return;
}
//
BOPDS_VectorOfInterfFF& aFFs=myDS->InterfFF();
Standard_Real aT;
Standard_Integer i, nV, nE, iC, aNbPB, iFlag;
BOPCol_ListIteratorOfListOfInteger aItLI;
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItBV;
//
BOPDS_VectorOfInterfFF& aFFs = myDS->InterfFF();
BOPDS_InterfFF& aFF = aFFs(theInt);
BOPDS_VectorOfCurve& aVC=aFF.ChangeCurves();
//
aItB.Initialize(aMVB);
for (; aItB.More(); aItB.Next()) {
nV = aItB.Value();
const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
const Bnd_Box& aBoxV=aSIV.Box();
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aSIV.Shape();
if (!aMVI.IsBound(aV)) {
continue;
}
BOPDS_VectorOfCurve& aVC = aFF.ChangeCurves();
//
aNbPB = aMPBOnIn.Extent();
//
aItBV.Initialize(aDMBV);
for (; aItBV.More(); aItBV.Next()) {
iC = aItBV.Key();
const BOPCol_ListOfInteger& aLBV = aItBV.Value();
//
aNbPB = aMPBOnIn.Extent();
for (i = 1; i <= aNbPB; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBOnIn(i);
if (aPB->Pave1().Index() == nV || aPB->Pave2().Index() == nV) {
BOPDS_Curve& aNC = aVC.ChangeValue(iC);
BOPDS_ListOfPaveBlock& aLPBC = aNC.ChangePaveBlocks();
//
aItLI.Initialize(aLBV);
for (; aItLI.More(); aItLI.Next()) {
nV = aItLI.Value();
const BOPDS_ShapeInfo& aSIV=myDS->ShapeInfo(nV);
const Bnd_Box& aBoxV=aSIV.Box();
const TopoDS_Vertex& aV = *(TopoDS_Vertex*)&aSIV.Shape();
if (!aMVI.IsBound(aV)) {
continue;
}
//
if (aMPB.Contains(aPB)) {
continue;
}
nE=aPB->Edge();
const BOPDS_ShapeInfo& aSIE=myDS->ShapeInfo(nE);
const Bnd_Box& aBoxE=aSIE.Box();
//
if (!aBoxV.IsOut(aBoxE)) {
for (i = 1; i <= aNbPB; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBOnIn(i);
if (aPB->Pave1().Index() == nV || aPB->Pave2().Index() == nV) {
continue;
}
//
if (aMPB.Contains(aPB)) {
continue;
}
//
nE = aPB->Edge();
const BOPDS_ShapeInfo& aSIE = myDS->ShapeInfo(nE);
const Bnd_Box& aBoxE = aSIE.Box();
//
if (aBoxV.IsOut(aBoxE)) {
continue;
}
//
const TopoDS_Edge& aE = *(TopoDS_Edge*)&aSIE.Shape();
//
iFlag=myContext->ComputeVE (aV, aE, aT);
iFlag = myContext->ComputeVE(aV, aE, aT);
if (!iFlag) {
aMPB.Add(aPB);
//
PreparePostTreatFF(theInt, aPB, aMSCPB, aMVI, aVC);
PreparePostTreatFF(theInt, iC, aPB, aMSCPB, aMVI, aLPBC);
}
}
}
@@ -1888,10 +1947,11 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
// 3. Update pave blocks
if (bCB) {
//create new common blocks
BOPDS_ListOfPaveBlock aLPBNew;
const BOPCol_ListOfInteger& aFaces = aCB1->Faces();
aIt.Initialize(aLPB);
for (; aIt.More(); aIt.Next()) {
Handle(BOPDS_PaveBlock)& aPB = aIt.ChangeValue();
const Handle(BOPDS_PaveBlock)& aPB = aIt.Value();
//
aCB = new BOPDS_CommonBlock;
aIt1.Initialize(aLPB1);
@@ -1911,8 +1971,11 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
aCB->AddFaces(aFaces);
myDS->SortPaveBlocks(aCB);
//
aPB=aCB->PaveBlocks().First();
const Handle(BOPDS_PaveBlock)& aPBNew = aCB->PaveBlocks().First();
aLPBNew.Append(aPBNew);
}
//
aLPB = aLPBNew;
}
else {
nE = aPBf->OriginalEdge();
@@ -2038,16 +2101,14 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
//=======================================================================
void BOPAlgo_PaveFiller::PreparePostTreatFF
(const Standard_Integer aInt,
const Standard_Integer aCur,
const Handle(BOPDS_PaveBlock)& aPB,
BOPDS_IndexedDataMapOfShapeCoupleOfPaveBlocks& aMSCPB,
BOPCol_DataMapOfShapeInteger& aMVI,
BOPDS_VectorOfCurve& aVC)
BOPDS_ListOfPaveBlock& aLPBC)
{
Standard_Integer nV1, nV2, iC;
Standard_Integer nV1, nV2;
//
aVC.Append1();
iC=aVC.Extent()-1;
BOPDS_ListOfPaveBlock& aLPBC = aVC(iC).ChangePaveBlocks();
aLPBC.Append(aPB);
//
aPB->Indices(nV1, nV2);
@@ -2057,7 +2118,7 @@ void BOPAlgo_PaveFiller::RemoveUsedVertices(BOPDS_Curve& aNC,
// Keep info for post treatment
BOPDS_CoupleOfPaveBlocks aCPB;
aCPB.SetIndexInterf(aInt);
aCPB.SetIndex(iC);
aCPB.SetIndex(aCur);
aCPB.SetPaveBlock1(aPB);
//
aMSCPB.Add(aE, aCPB);
@@ -2159,7 +2220,7 @@ void BOPAlgo_PaveFiller::UpdatePaveBlocks
}
//
if (bRebuild) {
nSp = SplitEdge(aPB->Edge(), nV[0], aT[0], nV[1], aT[1]);
nSp = SplitEdge(aPB->OriginalEdge(), nV[0], aT[0], nV[1], aT[1]);
if (bCB) {
aCB->SetEdge(nSp);
}

View File

@@ -17,8 +17,6 @@
#include <BOPAlgo_PaveFiller.ixx>
#include <NCollection_IncAllocator.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
@@ -63,6 +61,16 @@
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BRep_Builder.hxx>
#include <BRepBndLib.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
static
Standard_Boolean IsBasedOnPlane(const TopoDS_Face& aF);
@@ -296,13 +304,28 @@ class BOPAlgo_BPC {
myE=aE;
}
//
const TopoDS_Edge& GetEdge() const {
return myE;
}
const TopoDS_Face& GetFace() const {
return myF;
}
const Handle_Geom2d_Curve& GetCurve2d() const {
return myCurve;
}
Standard_Boolean IsToUpdate() const {
return myToUpdate;
}
//
void Perform() {
BOPTools_AlgoTools2D::BuildPCurveForEdgeOnPlane (myE, myF);
BOPTools_AlgoTools2D::BuildPCurveForEdgeOnPlane (myE, myF, myCurve, myToUpdate);
};
//
protected:
TopoDS_Edge myE;
TopoDS_Face myF;
Handle_Geom2d_Curve myCurve;
Standard_Boolean myToUpdate;
};
//=======================================================================
typedef BOPCol_NCVector
@@ -472,8 +495,8 @@ void BOPAlgo_PaveFiller::MakePCurves()
{
Standard_Boolean bHasPC;
Standard_Integer i, nF1, nF2, aNbC, k, nE, aNbFF, aNbFI, nEx;
Standard_Integer j, aNbPBIn, aNbPBOn;
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
TopoDS_Face aF1F, aF2F;
BOPAlgo_VectorOfMPC aVMPC;
//
@@ -491,9 +514,9 @@ void BOPAlgo_PaveFiller::MakePCurves()
aF1F.Orientation(TopAbs_FORWARD);
// In
const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
aItMPB.Initialize(aMPBIn);
for(; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
aNbPBIn = aMPBIn.Extent();
for (j = 1; j <= aNbPBIn; ++j) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBIn(j);
nE=aPB->Edge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
//
@@ -505,9 +528,9 @@ void BOPAlgo_PaveFiller::MakePCurves()
//
// On
const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
aItMPB.Initialize(aMPBOn);
for(; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
aNbPBOn = aMPBOn.Extent();
for (j = 1; j <= aNbPBOn; ++j) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBOn(j);
nE=aPB->Edge();
const TopoDS_Edge& aE=(*(TopoDS_Edge *)(&myDS->Shape(nE)));
bHasPC=BOPTools_AlgoTools2D::HasCurveOnSurface (aE, aF1F);
@@ -715,10 +738,9 @@ void BOPAlgo_PaveFiller::Prepare()
TopAbs_FACE
};
Standard_Boolean bJustAdd, bIsBasedOnPlane;
Standard_Integer i, aNb, n1, nF;
Standard_Integer i, aNb, n1, nF, aNbF;
TopExp_Explorer aExp;
BOPCol_MapOfShape aMF;
BOPCol_MapIteratorOfMapOfShape aItMF;
BOPCol_IndexedMapOfShape aMF;
//
myErrorStatus=0;
//
@@ -736,15 +758,16 @@ void BOPAlgo_PaveFiller::Prepare()
}
}
//
if (aMF.IsEmpty()) {
aNbF = aMF.Extent();
if (!aNbF) {
return;
}
//
// Build pcurves of edges on planes; first collect pairs edge-face.
BOPAlgo_VectorOfBPC aVBPC;
//
aItMF.Initialize(aMF);
for (; aItMF.More(); aItMF.Next()) {
const TopoDS_Face& aF=*((TopoDS_Face *)&aItMF.Key());
for (i = 1; i <= aNbF; ++i) {
const TopoDS_Face& aF = *(TopoDS_Face*)&aMF(i);
aExp.Init(aF, aType[1]);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE=*((TopoDS_Edge *)&aExp.Current());
@@ -757,6 +780,17 @@ void BOPAlgo_PaveFiller::Prepare()
//======================================================
BOPAlgo_BPCCnt::Perform(myRunParallel, aVBPC);
//======================================================
// pcurves are built, and now update edges
BRep_Builder aBB;
TopoDS_Edge E;
for (i = 0; i < aVBPC.Extent(); i++) {
const BOPAlgo_BPC& aBPC=aVBPC(i);
if (aBPC.IsToUpdate()) {
Standard_Real aTolE = BRep_Tool::Tolerance(aBPC.GetEdge());
aBB.UpdateEdge(aBPC.GetEdge(), aBPC.GetCurve2d(), aBPC.GetFace(), aTolE);
}
}
}
//=======================================================================
//function : IsBasedOnPlane

View File

@@ -19,8 +19,6 @@
#include <Precision.hxx>
#include <NCollection_IncAllocator.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Lin2d.hxx>
#include <ElCLib.hxx>
@@ -62,10 +60,10 @@ static
//function : ProcessDE
//purpose :
//=======================================================================
void BOPAlgo_PaveFiller::ProcessDE()
void BOPAlgo_PaveFiller::ProcessDE()
{
Standard_Integer nF, aNb, nE, nV, nVSD, aNbPB;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
Handle(BOPDS_PaveBlock) aPBD;
BOPCol_ListIteratorOfListOfInteger aItLI;
//
@@ -74,7 +72,8 @@ static
// 1. Find degnerated edges
//-----------------------------------------------------scope f
//
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
BOPDS_ListOfPaveBlock aLPBOut(aAllocator);
//
aNb=myDS->NbSourceShapes();
@@ -142,15 +141,14 @@ static
const Standard_Integer nF,
BOPDS_ListOfPaveBlock& aLPBOut)
{
Standard_Integer nV1, nV2;
BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
Standard_Integer i, aNbPBOn, aNbPBIn, aNbPBSc, nV1, nV2;
//
const BOPDS_FaceInfo& aFI=myDS->ChangeFaceInfo(nF);
// In
const BOPDS_IndexedMapOfPaveBlock& aMPBIn=aFI.PaveBlocksIn();
aItMPB.Initialize(aMPBIn);
for(; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
aNbPBIn = aMPBIn.Extent();
for (i = 1; i <= aNbPBIn; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBIn(i);
aPB->Indices(nV1, nV2);
if (nV==nV1 || nV==nV2) {
aLPBOut.Append(aPB);
@@ -158,9 +156,9 @@ static
}
// On
const BOPDS_IndexedMapOfPaveBlock& aMPBOn=aFI.PaveBlocksOn();
aItMPB.Initialize(aMPBOn);
for(; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
aNbPBOn = aMPBOn.Extent();
for (i = 1; i <= aNbPBOn; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBOn(i);
aPB->Indices(nV1, nV2);
if (nV==nV1 || nV==nV2) {
aLPBOut.Append(aPB);
@@ -168,9 +166,9 @@ static
}
// Sections
const BOPDS_IndexedMapOfPaveBlock& aMPBSc=aFI.PaveBlocksSc();
aItMPB.Initialize(aMPBSc);
for(; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
aNbPBSc = aMPBSc.Extent();
for (i = 1; i <= aNbPBSc; ++i) {
const Handle(BOPDS_PaveBlock)& aPB = aMPBSc(i);
aPB->Indices(nV1, nV2);
if (nV==nV1 || nV==nV2) {
aLPBOut.Append(aPB);
@@ -244,7 +242,7 @@ static
const Handle(BOPDS_PaveBlock)& aPBD)
{
Standard_Boolean bXDir, bIsDone;
Standard_Integer nE, aNbPoints, j;
Standard_Integer nE, aNbPoints, j, anInd;
Standard_Real aTD1, aTD2, aT1, aT2, aTolInter, aX, aDT;
Standard_Real aTolCmp;
gp_Pnt2d aP2d1, aP2d2, aP2D;
@@ -329,7 +327,7 @@ static
continue;
}
//
if (aPBD->ContainsParameter(aX, aDT)) {
if (aPBD->ContainsParameter(aX, aDT, anInd)) {
continue;
}
aPave.SetParameter(aX);

View File

@@ -14,8 +14,6 @@
#include <BOPAlgo_Section.ixx>
#include <NCollection_IncAllocator.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Compound.hxx>

View File

@@ -43,7 +43,8 @@ static
TopoDS_Shell& );
//
static
void RefineShell(TopoDS_Shell& theShell);
void RefineShell(TopoDS_Shell& theShell,
BOPCol_ListOfShape& aLShX);
//
static
void MapEdgesAndFaces
@@ -329,8 +330,9 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
BOPTools_CoupleOfShape aCSOff;
BOPCol_MapOfOrientedShape AddedFacesMap;
BOPCol_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP;
Handle (IntTools_Context) aContext;
//
Handle (IntTools_Context) aContext=new IntTools_Context;
aContext=new IntTools_Context;
//
const BOPCol_ListOfShape& myShapes=aCB.Shapes();
//
@@ -454,15 +456,18 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
} // for (; aExp.More(); aExp.Next()) {
} // for (; aItS.More(); aItS.Next()) {
//
if (BRep_Tool::IsClosed(aShell)) {
aShell.Closed (Standard_True);
myLoops.Append(aShell);
}
else {
RefineShell(aShell);
if (BRep_Tool::IsClosed(aShell)) {
aShell.Closed (Standard_True);
myLoops.Append(aShell);
BOPCol_ListOfShape aLShX;
BOPCol_ListIteratorOfListOfShape aItLShX;
//
RefineShell(aShell, aLShX);
//
aItLShX.Initialize(aLShX);
for (; aItLShX.More(); aItLShX.Next()) {
TopoDS_Shell& aShX=*((TopoDS_Shell*)&aItLShX.Value());
//
if (BRep_Tool::IsClosed(aShX)) {
aShX.Closed(Standard_True);
myLoops.Append(aShX);
}
}
} // for (; aItF.More(); aItF.Next()) {
@@ -471,7 +476,8 @@ void BOPAlgo_ShellSplitter::SplitBlock(BOPTools_ConnexityBlock& aCB)
//function : RefineShell
//purpose :
//=======================================================================
void RefineShell(TopoDS_Shell& theShell)
void RefineShell(TopoDS_Shell& theShell,
BOPCol_ListOfShape& aLShX)
{
TopoDS_Iterator aIt;
//
@@ -480,12 +486,12 @@ void RefineShell(TopoDS_Shell& theShell)
return;
}
//
Standard_Integer i, aNbMEF, aNbF;
Standard_Integer i, aNbMEF, aNbF, aNbMFB;
BOPCol_IndexedDataMapOfShapeListOfShape aMEF;
TopoDS_Builder aBB;
TopExp_Explorer aExp;
BOPCol_MapOfShape aMEStop, aMFB;
BOPCol_MapIteratorOfMapOfShape aItM;
BOPCol_IndexedMapOfShape aMFB;
BOPCol_MapOfShape aMEStop, aMFProcessed;
BOPCol_ListIteratorOfListOfShape aItLF, aItLFP;
BOPCol_ListOfShape aLFP, aLFP1;
//
@@ -494,6 +500,7 @@ void RefineShell(TopoDS_Shell& theShell)
TopAbs_EDGE,
TopAbs_FACE,
aMEF);
//
aNbMEF=aMEF.Extent();
for (i=1; i<=aNbMEF; ++i) {
const TopoDS_Shape& aE=aMEF.FindKey(i);
@@ -505,68 +512,89 @@ void RefineShell(TopoDS_Shell& theShell)
}
//
if (aMEStop.IsEmpty()) {
aLShX.Append(theShell);
return;
}
//
// The first Face
const TopoDS_Shape& aF1=aIt.Value();
aMFB.Add(aF1);
aLFP.Append(aF1);
//
// Trying to reach the branch point
for (;;) {
aItLFP.Initialize(aLFP);
for (; aItLFP.More(); aItLFP.Next()) {
const TopoDS_Shape& aFP=aItLFP.Value();
//
aExp.Init(aFP, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aExp.Current()));
if (aMEStop.Contains(aE)) {
continue;
}
//
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
const BOPCol_ListOfShape& aLF=aMEF.FindFromKey(aE);
//
aItLF.Initialize(aLF);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFP1=aItLF.Value();
if (aFP1.IsSame(aFP)) {
continue;
}
if (aMFB.Contains(aFP1)) {
continue;
}
aMFB.Add(aFP1);
aLFP1.Append(aFP1);
}// for (; aItLF.More(); aItLF.Next()) {
}// for (; aExp.More(); aExp.Next()) {
}// for (; aItLFP.More(); aItLFP.Next()) {
//
//
if (aLFP1.IsEmpty()) {
break;
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF1=aIt.Value();
if (!aMFProcessed.Add(aF1)) {
continue;
}
//
aMFB.Clear();
aLFP.Clear();
aItLF.Initialize(aLFP1);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFP1=aItLF.Value();
aLFP.Append(aFP1);
//
aMFB.Add(aF1);
aLFP.Append(aF1);
//
// Trying to reach the branch point
for (;;) {
aItLFP.Initialize(aLFP);
for (; aItLFP.More(); aItLFP.Next()) {
const TopoDS_Shape& aFP=aItLFP.Value();
//
aExp.Init(aFP, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE=(*(TopoDS_Edge*)(&aExp.Current()));
if (aMEStop.Contains(aE)) {
continue;
}
//
if (aE.Orientation() == TopAbs_INTERNAL) {
continue;
}
//
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
const BOPCol_ListOfShape& aLF=aMEF.FindFromKey(aE);
//
aItLF.Initialize(aLF);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFP1=aItLF.Value();
if (aFP1.IsSame(aFP)) {
continue;
}
if (aMFB.Contains(aFP1)) {
continue;
}
//
aMFProcessed.Add(aFP1);
aMFB.Add(aFP1);
aLFP1.Append(aFP1);
}// for (; aItLF.More(); aItLF.Next()) {
}// for (; aExp.More(); aExp.Next()) {
} // for (; aItLFP.More(); aItLFP.Next()) {
//
//
if (aLFP1.IsEmpty()) {
break;
}
//
aLFP.Clear();
aItLF.Initialize(aLFP1);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFP1=aItLF.Value();
aLFP.Append(aFP1);
}
aLFP1.Clear();
}// for (;;) {
//
aNbMFB=aMFB.Extent();
if (aNbMFB) {
TopoDS_Shell aShX;
aBB.MakeShell(aShX);
//
for (i=1; i<=aNbMFB; ++i) {
const TopoDS_Shape& aFB=aMFB(i);
aBB.Add(aShX, aFB);
}
aLShX.Append(aShX);
}
aLFP1.Clear();
}// for (;;) {
//
// Remove all faces before the branch point
aItM.Initialize(aMFB);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aFB=aItM.Value();
aBB.Remove(theShell, aFB);
}
}//for (; aIt.More(); aIt.Next()) {
}
//=======================================================================
//function : MakeShells

View File

@@ -120,7 +120,6 @@ void BOPAlgo_WireSplitter::MakeConnexityBlocks()
TopoDS_Iterator aItE;
TopoDS_Shape aER;
BOPCol_ListIteratorOfListOfShape aIt;
BOPCol_MapIteratorOfMapOfShape aItM;
//
BOPCol_IndexedDataMapOfShapeListOfShape aMVE(100, myAllocator);
BOPCol_IndexedMapOfShape aMVP(100, myAllocator);
@@ -184,7 +183,7 @@ void BOPAlgo_WireSplitter::MakeConnexityBlocks()
}
}
}
}//for (; aItM.More(); aItM.Next()) {
}//for (k=1; k<=aNbVP; ++k) {
//
aNbVP=aMVAdd.Extent();
if (!aNbVP) {

View File

@@ -13,6 +13,7 @@
// commercial license or contractual agreement.
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <TopoDS_Edge.hxx>
@@ -85,7 +86,7 @@ typedef NCollection_IndexedDataMap<TopoDS_Shape, \
//purpose :
//=======================================================================
inline void BOPAlgo_WireSplitter::MakeWire(BOPCol_ListOfShape& aLE,
TopoDS_Wire& aWire)
TopoDS_Wire& aWire)
{
BRep_Builder aBB;
aBB.MakeWire(aWire);
@@ -94,4 +95,5 @@ typedef NCollection_IndexedDataMap<TopoDS_Shape, \
for (; aIt.More(); aIt.Next()){
aBB.Add(aWire, aIt.Value());
}
aWire.Closed(BRep_Tool::IsClosed(aWire));
}

View File

@@ -14,15 +14,19 @@
#include <BOPAlgo_WireSplitter.ixx>
#include <Precision.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_Dir2d.hxx>
#include <Geom_Surface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <BOPAlgo_WireEdgeSet.hxx>
#include <BOPAlgo_WireSplitter.hxx>
#include <BOPCol_IndexedDataMapOfShapeInteger.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_SequenceOfPnt2d.hxx>
#include <BOPCol_SequenceOfReal.hxx>
#include <BOPCol_SequenceOfShape.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_Line.hxx>
#include <GeomAdaptor_Surface.hxx>
@@ -42,9 +46,6 @@
#include <BRep_Builder.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BOPCol_ListOfShape.hxx>
@@ -752,7 +753,8 @@ Standard_Integer NbWaysOut(const BOPAlgo_ListOfEdgeInfo& aLEInfo)
GeomAbs_CurveType aType;
Geom2dAdaptor_Curve aGAC2D(aC2D);
aType=aGAC2D.GetType();
if (aType==GeomAbs_BSplineCurve || aType==GeomAbs_BezierCurve) {
if (aType==GeomAbs_BSplineCurve ||
aType==GeomAbs_BezierCurve) {
dt=1.1*dt;
}
if (fabs (aTV-aFirst) < fabs(aTV - aLast)) {
@@ -762,10 +764,25 @@ Standard_Integer NbWaysOut(const BOPAlgo_ListOfEdgeInfo& aLEInfo)
aTV1=aTV - dt;
}
//
aC2D->D0 (aTV1, aPV1);
aC2D->D0 (aTV, aPV);
if (aType==GeomAbs_Circle) {
Standard_Real aTM;
TopAbs_Orientation aOrE;
gp_Pnt2d aPM;
//
aTM=0.5*(aTV1+aTV);
//
aC2D->D1(aTM, aPM, aV2D);
aOrE=anEdge.Orientation();
if (aOrE==TopAbs_REVERSED) {
aV2D.Reverse();
}
}
else {
aC2D->D0 (aTV1, aPV1);
aC2D->D0 (aTV, aPV);
//
aV2D = bIsIN ? gp_Vec2d(aPV1, aPV) : gp_Vec2d(aPV, aPV1);
}
//
gp_Dir2d aDir2D(aV2D);
anAngle=Angle(aDir2D);
@@ -848,8 +865,7 @@ void RefineAngles(const TopoDS_Face& myFace,
BOPAlgo_IndexedDataMapOfShapeListOfEdgeInfo& mySmartMap)
{
Standard_Integer aNb, i;
BOPCol_DataMapOfShapeInteger aMSI;
BOPCol_DataMapIteratorOfDataMapOfShapeInteger aItMSI;
BOPCol_IndexedDataMapOfShapeInteger aMSI;
BOPCol_MapOfShape aMBE;
BOPCol_ListIteratorOfListOfShape aIt;
//
@@ -857,32 +873,29 @@ void RefineAngles(const TopoDS_Face& myFace,
aIt.Initialize(myEdges);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
if(aMSI.IsBound(aE)) {
Standard_Integer& iCnt=aMSI.ChangeFind(aE);
if(aMSI.Contains(aE)) {
Standard_Integer& iCnt = aMSI.ChangeFromKey(aE);
++iCnt;
}
else {
Standard_Integer iCnt=1;
aMSI.Bind(aE, iCnt);
Standard_Integer iCnt = 1;
aMSI.Add(aE, iCnt);
}
}
//
aItMSI.Initialize(aMSI);
for(; aItMSI.More(); aItMSI.Next()) {
Standard_Integer iCnt;
//
const TopoDS_Shape& aE=aItMSI.Key();
iCnt=aItMSI.Value();
if (iCnt==1) {
aNb = aMSI.Extent();
for (i = 1; i <= aNb; ++i) {
Standard_Integer iCnt = aMSI(i);
if (iCnt == 1) {
const TopoDS_Shape& aE = aMSI.FindKey(i);
aMBE.Add(aE);
}
}
//
aMSI.Clear();
//
aNb=mySmartMap.Extent();
for (i=1; i<=aNb; ++i) {
aNb = mySmartMap.Extent();
for (i = 1; i <= aNb; ++i) {
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&mySmartMap.FindKey(i));
BOPAlgo_ListOfEdgeInfo& aLEI=mySmartMap(i);
//

View File

@@ -49,6 +49,7 @@ is
imported DataMapOfIntegerListOfShape from BOPCol;
imported IndexedDataMapOfIntegerListOfInteger from BOPCol;
imported IndexedDataMapOfShapeInteger from BOPCol;
imported IndexedDataMapOfShapeShape;
imported IndexedMapOfOrientedShape;
end BOPCol;

View File

@@ -1,5 +1,5 @@
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
// Created by: Eugeny MALTCHIKOV
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
@@ -12,29 +12,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef math_Memory_HeaderFile
#define math_Memory_HeaderFile
#ifndef BOPCol_IndexedDataMapOfShapeShape_HeaderFile
#define BOPCol_IndexedDataMapOfShapeShape_HeaderFile
#include <string.h>
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
// uniquement parce que memmove n'existe pas sur SUN
#ifndef WNT
void *reverse_move(void *s1, void *s2, int size);
#include <NCollection_IndexedDataMap.hxx>
inline void *memmove(void *s1, void *s2, int size) {
typedef NCollection_IndexedDataMap<TopoDS_Shape, TopoDS_Shape, TopTools_ShapeMapHasher> BOPCol_IndexedDataMapOfShapeShape;
/*
void *result;
if(s2 < s1) {
result = reverse_move(s1, s2, size);
}
else {
result = memcpy(s1, s2, size);
}
return result;
*/
return memcpy(s1, s2, size);
}
#endif
#endif

View File

@@ -1,6 +1,5 @@
// Created on: 2014-12-18
// Created by: Kirill Gavrilov
// Copyright (c) 2014 OPEN CASCADE SAS
// Created by: Eugeny MALTCHIKOV
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
@@ -13,12 +12,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _OpenGl_SequenceOfStructure
#define _OpenGl_SequenceOfStructure
#ifndef BOPCol_IndexedMapOfOrientedShape_HeaderFile
#define BOPCol_IndexedMapOfOrientedShape_HeaderFile
#include <NCollection_Sequence.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_OrientedShapeMapHasher.hxx>
class OpenGl_Structure;
typedef NCollection_Sequence<const OpenGl_Structure*> OpenGl_SequenceOfStructure;
#include <NCollection_IndexedMap.hxx>
#endif // _OpenGl_SequenceOfStructure
typedef NCollection_IndexedMap<TopoDS_Shape, TopTools_OrientedShapeMapHasher> BOPCol_IndexedMapOfOrientedShape;
#endif

View File

@@ -19,6 +19,8 @@ BOPCol_DataMapOfShapeListOfShape.hxx
BOPCol_MapOfOrientedShape.hxx
BOPCol_IndexedDataMapOfShapeListOfShape.hxx
BOPCol_IndexedMapOfShape.hxx
BOPCol_IndexedDataMapOfShapeShape.hxx
BOPCol_IndexedMapOfOrientedShape.hxx
BOPCol_ListOfListOfShape.hxx
BOPCol_SequenceOfShape.hxx
BOPCol_SequenceOfPnt2d.hxx

View File

@@ -16,7 +16,6 @@
//
#include <Standard_Assert.hxx>
//
#include <NCollection_IncAllocator.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <gp_Pnt.hxx>
@@ -354,7 +353,7 @@ void BOPDS_DS::Init()
BOPCol_ListIteratorOfListOfInteger aIt1, aIt2, aIt3;
BOPCol_ListIteratorOfListOfShape aIt;
BOPDS_IndexRange aR;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
//
// 1 Append Source Shapes
aNb=myArguments.Extent();
@@ -382,7 +381,8 @@ void BOPDS_DS::Init()
//
myLines.SetIncrement(2*aNbS);
//-----------------------------------------------------scope_1 f
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_DataMapOfShapeInteger& aMSI=myMapShapeIndex;
//
@@ -647,7 +647,6 @@ void BOPDS_DS::Init()
}//for (j=0; j<myNbSourceShapes; ++j) {
//
aMI.Clear();
aAllocator.Nullify();
//-----------------------------------------------------scope_1 t
// 3 myPaveBlocksPool
// 4. myFaceInfoPool
@@ -1363,7 +1362,7 @@ void BOPDS_DS::FaceInfoIn(const Standard_Integer theF,
if (aSx.ShapeType()==TopAbs_VERTEX){
nV=Index(aSx);
if (HasShapeSD(nV, nVSD)) {
nV=nVSD;
nV=nVSD;
}
theMI.Add(nV);
}
@@ -1446,20 +1445,19 @@ void BOPDS_DS::AloneVertices(const Standard_Integer theI,
{
if (HasFaceInfo(theI)) {
//
Standard_Integer i, nV1, nV2, nV;
BOPDS_MapIteratorOfMapOfPaveBlock aItMPB;
Standard_Integer i, j, nV1, nV2, nV, aNbPB;
BOPCol_MapIteratorOfMapOfInteger aItMI;
//
BOPCol_MapOfInteger aMI(100, myAllocator);
//
const BOPDS_FaceInfo& aFI=FaceInfo(theI);
//
for (i=0; i<2; ++i) {
for (i = 0; i < 2; ++i) {
const BOPDS_IndexedMapOfPaveBlock& aMPB=
(!i) ? aFI.PaveBlocksIn() : aFI.PaveBlocksSc();
aItMPB.Initialize(aMPB);
for (; aItMPB.More(); aItMPB.Next()) {
const Handle(BOPDS_PaveBlock)& aPB=aItMPB.Value();
aNbPB = aMPB.Extent();
for (j = 1; j <= aNbPB; ++j) {
const Handle(BOPDS_PaveBlock)& aPB = aMPB(j);
aPB->Indices(nV1, nV2);
aMI.Add(nV1);
aMI.Add(nV2);

View File

@@ -19,7 +19,6 @@
//
#include <Bnd_Box.hxx>
//
#include <NCollection_IncAllocator.hxx>
#include <NCollection_UBTreeFiller.hxx>
//
#include <TopoDS_Shape.hxx>
@@ -270,11 +269,11 @@ void BOPDS_Iterator::Intersect()
Standard_Integer aNb, i, aNbR, iTi, iTj;
Standard_Integer i1, i2, aNbSD, iX, j, iR;
TopAbs_ShapeEnum aTi, aTj;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfInteger aIt;
//
//-----------------------------------------------------scope_1 f
aAllocator=new NCollection_IncAllocator();
aAllocator=NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPDS_MapOfPassKeyBoolean aMPKXB(100, aAllocator);
BOPDS_PassKeyBoolean aPKXB;
@@ -373,6 +372,5 @@ void BOPDS_Iterator::Intersect()
//
aMPKXB.Clear();
aVTSR.Clear();
aAllocator.Nullify();
//-----------------------------------------------------scope_1 t
}

View File

@@ -24,7 +24,6 @@
#include <BRep_Tool.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_IncAllocator.hxx>
#include <BOPCol_BoxBndTree.hxx>
#include <BOPDS_IndexRange.hxx>
@@ -37,7 +36,6 @@
#include <BOPCol_DataMapOfShapeInteger.hxx>
#include <BOPCol_DataMapOfIntegerInteger.hxx>
#include <BOPCol_DataMapOfIntegerListOfInteger.hxx>
#include <BOPCol_IndexedMapOfInteger.hxx>
#include <BOPDS_ShapeInfo.hxx>
#include <BOPCol_ListOfInteger.hxx>
#include <BOPCol_IndexedMapOfInteger.hxx>
@@ -91,12 +89,12 @@ void BOPDS_IteratorSI::Intersect()
Standard_Integer aNbS, i, aNbB;
Standard_Integer aNbSD, iX, j, iDS, jB;
TopAbs_ShapeEnum aTi, aTj;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfInteger aIt;
BOPCol_DataMapIteratorOfDataMapOfIntegerListOfInteger aItVSD;
//
//-----------------------------------------------------scope_1 f
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_DataMapOfShapeInteger aMSI(100, aAllocator);
BOPCol_DataMapOfIntegerInteger aMII(100, aAllocator);
@@ -124,10 +122,10 @@ void BOPDS_IteratorSI::Intersect()
const BOPCol_ListOfInteger& aLA=aSI.SubShapes();
aIt.Initialize(aLA);
for (; aIt.More(); aIt.Next()) {
iX=aIt.Value();
aPKXB.Clear();
aPKXB.SetIds(i, iX);
aMPA.Add(aPKXB);
iX=aIt.Value();
aPKXB.Clear();
aPKXB.SetIds(i, iX);
aMPA.Add(aPKXB);
}
}
//
@@ -206,6 +204,5 @@ void BOPDS_IteratorSI::Intersect()
aMPKXB.Clear();
aMSB.Clear();
//
aAllocator.Nullify();
//-----------------------------------------------------scope_1 t
}

View File

@@ -186,13 +186,15 @@ is
ContainsParameter(me;
thePrm:Real from Standard;
theTol:Real from Standard)
theTol:Real from Standard;
theInd: in out Integer from Standard)
returns Boolean from Standard;
---Purpose:
--- Query
--- Returns true if the extra paves contain the pave
--- with given value of the parameter <thePrm>
--- <theTol> - the value of the tolerance to compare
--- <theInd> - index of the found pave
--
-- shrunk data

View File

@@ -234,21 +234,19 @@
//purpose :
//=======================================================================
Standard_Boolean BOPDS_PaveBlock::ContainsParameter(const Standard_Real theT,
const Standard_Real theTol)const
const Standard_Real theTol,
Standard_Integer& theInd) const
{
Standard_Boolean bRet;
Standard_Real dT;
BOPDS_ListIteratorOfListOfPave aIt;
//
bRet=Standard_False;
bRet = Standard_False;
aIt.Initialize(myExtPaves);
for (; aIt.More(); aIt.Next()) {
dT=aIt.Value().Parameter()-theT;
if (dT<0.) {
dT=-dT;
}
if (dT<theTol) {
bRet=!bRet;
const BOPDS_Pave& aPave = aIt.Value();
bRet = (Abs(aPave.Parameter() - theT) < theTol);
if (bRet) {
theInd = aPave.Index();
break;
}
}

View File

@@ -16,7 +16,6 @@
//
#include <Bnd_Box.hxx>
//
#include <NCollection_IncAllocator.hxx>
#include <NCollection_UBTreeFiller.hxx>
//
#include <TopoDS.hxx>
@@ -141,7 +140,7 @@
// purpose:
//=======================================================================
void BOPDS_SubIterator::Value(Standard_Integer& theI1,
Standard_Integer& theI2) const
Standard_Integer& theI2) const
{
Standard_Integer iT1, iT2, n1, n2;
//
@@ -181,12 +180,13 @@
void BOPDS_SubIterator::Intersect()
{
Standard_Integer i, aNbB, aNbSD, j, iDS, jB;
Handle(NCollection_IncAllocator) aAllocator;
Handle(NCollection_BaseAllocator) aAllocator;
BOPCol_ListIteratorOfListOfInteger aIt, aIt1, aIt2;
BOPDS_PassKeyBoolean aPKXB;
//
//-----------------------------------------------------scope_1 f
aAllocator=new NCollection_IncAllocator();
aAllocator=
NCollection_BaseAllocator::CommonBaseAllocator();
//
BOPCol_DataMapOfShapeInteger aMSI(100, aAllocator);
BOPCol_DataMapOfIntegerInteger aMII(100, aAllocator);
@@ -243,7 +243,7 @@
//
aPKXB.SetIds(i, j);
if (aMPKXB.Add(aPKXB)) {
myList.Append(aPKXB);
myList.Append(aPKXB);
}// if (aMPKXB.Add(aPKXB)) {
}// for (; aIt.More(); aIt.Next()) {
}
@@ -253,6 +253,5 @@
aMPKXB.Clear();
aMSB.Clear();
//
aAllocator.Nullify();
//-----------------------------------------------------scope_1 t
}

View File

@@ -41,6 +41,8 @@ is
PartitionCommands (aDI:out Interpretor from Draw);
APICommands (aDI:out Interpretor from Draw);
OptionCommands (aDI:out Interpretor from Draw);
HistoryCommands (aDI:out Interpretor from Draw);
Factory (aDI:out Interpretor from Draw);
end BOPTest;

View File

@@ -38,8 +38,9 @@ void BOPTest::AllCommands(Draw_Interpretor& theCommands)
BOPTest::TolerCommands (theCommands);
BOPTest::ObjCommands (theCommands);
BOPTest::PartitionCommands (theCommands);
BOPTest::APICommands (theCommands);
BOPTest::OptionCommands (theCommands);
BOPTest::APICommands (theCommands);
BOPTest::OptionCommands (theCommands);
BOPTest::HistoryCommands (theCommands);
}
//=======================================================================
//function : Factory

View File

@@ -25,7 +25,6 @@
#include <Draw.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <NCollection_IncAllocator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Compound.hxx>
@@ -35,6 +34,7 @@
#include <IntTools_FaceFace.hxx>
#include <IntTools_Curve.hxx>
#include <IntTools_PntOn2Faces.hxx>
#include <BOPCol_ListOfShape.hxx>
@@ -160,7 +160,8 @@ Standard_Integer bop(Draw_Interpretor& di,
delete pPF;
pPF=NULL;
}
Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
Handle(NCollection_BaseAllocator)aAL=
NCollection_BaseAllocator::CommonBaseAllocator();
pPF=new BOPAlgo_PaveFiller(aAL);
//
pPF->SetArguments(aLC);
@@ -491,7 +492,8 @@ Standard_Integer bsmt (Draw_Interpretor& di,
aTol=BOPTest_Objects::FuzzyValue();
bRunParallel = BOPTest_Objects::RunParallel();
//
Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
Handle(NCollection_BaseAllocator)aAL=
NCollection_BaseAllocator::CommonBaseAllocator();
//
//---------------------------------------------------------------
BOPAlgo_PaveFiller aPF(aAL);
@@ -641,9 +643,9 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
const TopoDS_Face& aF2=*(TopoDS_Face*)(&S2);
//
Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone;
Standard_Integer i, aNbCurves;
Standard_Integer i, aNbCurves, aNbPoints;
Standard_Real anAppTol, aTolR;
TCollection_AsciiString aNm("c_");
TCollection_AsciiString aNm("c_"), aNp("p_");
//
anAppTol = 0.0000001;
aToApproxC3d = Standard_True;
@@ -678,77 +680,98 @@ Standard_Integer bopcurves (Draw_Interpretor& di,
//
anIsDone=aFF.IsDone();
if (!anIsDone) {
di << " anIsDone=" << (Standard_Integer) anIsDone << "\n";
return 1;
di << "Error: anIsDone=" << (Standard_Integer) anIsDone << "\n";
return 0;
}
//
aFF.PrepareLines3D(Standard_False);
const IntTools_SequenceOfCurves& aSCs=aFF.Lines();
const IntTools_SequenceOfPntOn2Faces& aSPs = aFF.Points();
//
aNbCurves = aSCs.Length();
aNbPoints = aSPs.Length();
if (!aNbCurves && !aNbPoints) {
di << " has no 3d curves\n";
di << " has no 3d points\n";
return 0;
}
//
aTolR=aFF.TolReached3d();
di << "Tolerance Reached=" << aTolR << "\n";
aNbCurves=aSCs.Length();
if (!aNbCurves) {
di << " has no 3d curve\n";
return 1;
}
else
{
//
// curves
if (aNbCurves) {
di << aNbCurves << " curve(s) found.\n";
}
for (i=1; i<=aNbCurves; i++) {
const IntTools_Curve& anIC=aSCs(i);
Handle (Geom_Curve) aC3D = anIC.Curve();
if (aC3D.IsNull()) {
di << " has Null 3d curve# " << i << "\n";
continue;
}
TCollection_AsciiString anIndx(i), aNmx;
aNmx = aNm + anIndx;
Standard_CString nameC = aNmx.ToCString();
DrawTrSurf::Set(nameC, aC3D);
di << nameC << " ";
//
Handle(Geom2d_Curve) aPC1 = anIC.FirstCurve2d();
Handle(Geom2d_Curve) aPC2 = anIC.SecondCurve2d();
//
if (!aPC1.IsNull() || !aPC2.IsNull()) {
di << "(";
//
if (!aPC1.IsNull()) {
TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
pc1Nx = pc1N + anIndx;
Standard_CString nameC2d1 = pc1Nx.ToCString();
//
DrawTrSurf::Set(nameC2d1, aPC1);
di << nameC2d1;
for (i=1; i<=aNbCurves; i++) {
const IntTools_Curve& anIC=aSCs(i);
Handle (Geom_Curve) aC3D = anIC.Curve();
if (aC3D.IsNull()) {
di << " has Null 3d curve# " << i << "\n";
continue;
}
TCollection_AsciiString anIndx(i), aNmx;
aNmx = aNm + anIndx;
Standard_CString nameC = aNmx.ToCString();
DrawTrSurf::Set(nameC, aC3D);
di << nameC << " ";
//
if (!aPC2.IsNull()) {
TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
pc2Nx = pc2N + anIndx;
Standard_CString nameC2d2 = pc2Nx.ToCString();
//
DrawTrSurf::Set(nameC2d2, aPC2);
Handle(Geom2d_Curve) aPC1 = anIC.FirstCurve2d();
Handle(Geom2d_Curve) aPC2 = anIC.SecondCurve2d();
//
if (!aPC1.IsNull() || !aPC2.IsNull()) {
di << "(";
//
if (!aPC1.IsNull()) {
di << ", ";
TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
pc1Nx = pc1N + anIndx;
Standard_CString nameC2d1 = pc1Nx.ToCString();
//
DrawTrSurf::Set(nameC2d1, aPC1);
di << nameC2d1;
}
di << nameC2d2;
//
if (!aPC2.IsNull()) {
TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
pc2Nx = pc2N + anIndx;
Standard_CString nameC2d2 = pc2Nx.ToCString();
//
DrawTrSurf::Set(nameC2d2, aPC2);
//
if (!aPC1.IsNull()) {
di << ", ";
}
di << nameC2d2;
}
di << ") ";
}
di << ") ";
}
di << "\n";
}
//
// points
if (aNbPoints) {
di << aNbPoints << " point(s) found.\n";
//
for (i = 1; i <= aNbPoints; i++) {
const IntTools_PntOn2Faces& aPi = aSPs(i);
const gp_Pnt& aP = aPi.P1().Pnt();
//
TCollection_AsciiString anIndx(i), aNmx;
aNmx = aNp + anIndx;
Standard_CString nameP = aNmx.ToCString();
//
DrawTrSurf::Set(nameP, aP);
di << nameP << " ";
}
di << "\n";
}
//
di << "\n";
return 0;
}
//=======================================================================

View File

@@ -388,7 +388,9 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
Standard_Boolean isS2 = Standard_False;
Standard_Integer indxS2 = 0;
Standard_Real aTolerance = 0;
Standard_Boolean bRunParallel;
//
bRunParallel=BOPTest_Objects::RunParallel();
aTolerance=BOPTest_Objects::FuzzyValue();
if(n >= 3) {
@@ -433,6 +435,7 @@ Standard_Integer bopargcheck (Draw_Interpretor& di,
// init checker
BOPAlgo_ArgumentAnalyzer aChecker;
aChecker.SetRunParallel(bRunParallel);
aChecker.SetFuzzyValue(aTolerance);
aChecker.SetShape1(aS1);
@@ -999,7 +1002,7 @@ Standard_Integer checkcurveonsurf(Draw_Interpretor& di,
}
//
aTolE = BRep_Tool::Tolerance(aE);
if (aDMax < aTolE) {
if (!(aDMax > aTolE)) {
continue;
}
//

View File

@@ -0,0 +1,184 @@
// Created by: Eugeny MALTCHIKOV
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BOPTest.ixx>
//
#include <Draw.hxx>
#include <DBRep.hxx>
//
#include <BRep_Builder.hxx>
//
#include <TopoDS_Compound.hxx>
//
#include <BOPAlgo_Builder.hxx>
//
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
//
#include <BOPTest_DrawableShape.hxx>
#include <BOPTest_Objects.hxx>
//
static Standard_Integer bmodified (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bgenerated (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer bisdeleted (Draw_Interpretor&, Standard_Integer, const char**);
//=======================================================================
//function : HistoryCommands
//purpose :
//=======================================================================
void BOPTest::HistoryCommands(Draw_Interpretor& theCommands)
{
static Standard_Boolean done = Standard_False;
if (done) return;
done = Standard_True;
// Chapter's name
const char* g = "BOPTest commands";
// Commands
theCommands.Add("bmodified" , "Use: bmodified rc shape", __FILE__, bmodified , g);
theCommands.Add("bgenerated", "Use: bgenerated rc shape", __FILE__, bgenerated, g);
theCommands.Add("bisdeleted", "Use: bisdeleted shape" , __FILE__, bisdeleted, g);
}
//=======================================================================
//function : bmodified
//purpose :
//=======================================================================
Standard_Integer bmodified(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n < 3) {
di << "Use: bmodified rc shape\n";
return 1;
}
//
TopoDS_Shape aS = DBRep::Get(a[2]);
if (aS.IsNull()) {
di << "Null shape\n";
return 1;
}
//
TopAbs_ShapeEnum aType = aS.ShapeType();
if (!(aType==TopAbs_VERTEX || aType==TopAbs_EDGE ||
aType==TopAbs_FACE || aType==TopAbs_SOLID)) {
di << "The shape must be one of the following types: VERTEX, EDGE, FACE or SOLID\n";
return 1;
}
//
BOPAlgo_Builder& aBuilder = BOPTest_Objects::Builder();
const TopTools_ListOfShape& aLS = aBuilder.Modified(aS);
//
if (aLS.IsEmpty()) {
di << "The shape has not been modified\n";
return 0;
}
//
BRep_Builder aBB;
TopoDS_Compound aRes;
//
aBB.MakeCompound(aRes);
TopTools_ListIteratorOfListOfShape aIt(aLS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aBB.Add(aRes, aS);
}
//
DBRep::Set(a[1], aRes);
//
return 0;
}
//=======================================================================
//function : bgenerated
//purpose :
//=======================================================================
Standard_Integer bgenerated(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n < 3) {
di << "Use: bgenerated rc shape\n";
return 1;
}
//
TopoDS_Shape aS = DBRep::Get(a[2]);
if (aS.IsNull()) {
di << "Null shape\n";
return 1;
}
//
TopAbs_ShapeEnum aType = aS.ShapeType();
if (!(aType==TopAbs_VERTEX || aType==TopAbs_EDGE ||
aType==TopAbs_FACE || aType==TopAbs_SOLID)) {
di << "The shape must be one of the following types: VERTEX, EDGE, FACE or SOLID\n";
return 1;
}
//
BOPAlgo_Builder& aBuilder = BOPTest_Objects::Builder();
const TopTools_ListOfShape& aLS = aBuilder.Generated(aS);
//
if (aLS.IsEmpty()) {
di << "No shapes were generated from the shape\n";
return 0;
}
//
BRep_Builder aBB;
TopoDS_Compound aRes;
//
aBB.MakeCompound(aRes);
TopTools_ListIteratorOfListOfShape aIt(aLS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS = aIt.Value();
aBB.Add(aRes, aS);
}
//
DBRep::Set(a[1], aRes);
//
return 0;
}
//=======================================================================
//function : bisdeleted
//purpose :
//=======================================================================
Standard_Integer bisdeleted(Draw_Interpretor& di,
Standard_Integer n,
const char** a)
{
if (n < 2) {
di << "Use: bisdeleted shape\n";
return 1;
}
//
TopoDS_Shape aS = DBRep::Get(a[1]);
if (aS.IsNull()) {
di << "Null shape\n";
return 1;
}
//
TopAbs_ShapeEnum aType = aS.ShapeType();
if (!(aType==TopAbs_VERTEX || aType==TopAbs_EDGE ||
aType==TopAbs_FACE || aType==TopAbs_SOLID)) {
di << "The shape must be one of the following types: VERTEX, EDGE, FACE or SOLID\n";
return 1;
}
//
BOPAlgo_Builder& aBuilder = BOPTest_Objects::Builder();
Standard_Boolean isDeleted = aBuilder.IsDeleted(aS);
//
di << (isDeleted ? "Deleted" : "Not deleted") << "\n";
//
return 0;
}

View File

@@ -15,7 +15,6 @@
#include <BOPTest_Objects.ixx>
#include <NCollection_BaseAllocator.hxx>
#include <NCollection_IncAllocator.hxx>
static Handle(NCollection_BaseAllocator)& Allocator1();
@@ -38,8 +37,8 @@ class BOPTest_Session {
void Init() {
Handle(NCollection_BaseAllocator) pA1, pA2;
//
pA1=new NCollection_IncAllocator;
pA2=new NCollection_IncAllocator;
pA1=NCollection_BaseAllocator::CommonBaseAllocator();
pA2=NCollection_BaseAllocator::CommonBaseAllocator();
//
myPaveFiller=new BOPAlgo_PaveFiller(pA1);
myBuilderDefault=new BOPAlgo_Builder(pA2);
@@ -275,6 +274,6 @@ Standard_Real BOPTest_Objects::FuzzyValue()
Handle(NCollection_BaseAllocator)& Allocator1()
{
static Handle(NCollection_BaseAllocator) sAL1=
new NCollection_IncAllocator;
NCollection_BaseAllocator::CommonBaseAllocator();
return sAL1;
}

View File

@@ -16,9 +16,6 @@
#include <stdio.h>
#include <string.h>
#include <NCollection_IncAllocator.hxx>
#include <DBRep.hxx>
#include <Draw.hxx>
#include <Draw_Color.hxx>
@@ -162,6 +159,7 @@ Standard_Integer bbuild(Draw_Interpretor& di,
//
BOPAlgo_PaveFiller& aPF=BOPTest_Objects::PaveFiller();
//
BOPTest_Objects::SetBuilderDefault();
BOPAlgo_Builder& aBuilder=BOPTest_Objects::Builder();
aBuilder.Clear();
//
@@ -324,6 +322,8 @@ Standard_Integer bbop(Draw_Interpretor& di,
return 0;
}
//
BOPTest_Objects::SetBuilder(pBuilder);
//
DBRep::Set(a[1], aR);
return 0;
}

View File

@@ -6,3 +6,6 @@ BOPTest_TolerCommands.cxx
BOPTest_ObjCommands.cxx
BOPTest_APICommands.cxx
BOPTest_OptionCommands.cxx
BOPTest_PartitionCommands.cxx
BOPTest_TolerCommands.cxx
BOPTest_HistoryCommands.cxx

View File

@@ -38,7 +38,8 @@ is
aF: Face from TopoDS);
---Purpose:
--- Compute P-Curve for the edge <aE> on the face <aF>
---
--- Raises exception Standard_ConstructionError if projection algorithm fails
EdgeTangent (myclass;
anE : Edge from TopoDS;
aT : Real from Standard;
@@ -56,8 +57,11 @@ is
V : out Real from Standard);
---Purpose:
--- Compute surface parameters <U,V> of the face <aF>
--- for the point from the edge <aE> at parameter <aT>.
---
--- for the point from the edge <aE> at parameter <aT>.
--- If <aE> has't pcurve on surface, algorithm tries to get it by
--- projection and can
--- raise exception Standard_ConstructionError if projection algorithm fails
CurveOnSurface (myclass;
aE: Edge from TopoDS;
aF: Face from TopoDS;
@@ -67,7 +71,8 @@ is
--- Get P-Curve <aC> for the edge <aE> on surface <aF> .
--- If the P-Curve does not exist, build it using Make2D().
--- [aToler] - reached tolerance
---
--- Raises exception Standard_ConstructionError if algorithm Make2D() fails
CurveOnSurface (myclass;
aE: Edge from TopoDS;
aF: Face from TopoDS;
@@ -81,7 +86,8 @@ is
--- If the P-Curve does not exist, build it using Make2D().
--- [aFirst, aLast] - range of the P-Curve
--- [aToler] - reached tolerance
---
--- Raises exception Standard_ConstructionError if algorithm Make2D() fails
HasCurveOnSurface (myclass;
aE: Edge from TopoDS;
aF: Face from TopoDS;
@@ -152,6 +158,12 @@ is
theE : Edge from TopoDS;
theF : Face from TopoDS);
BuildPCurveForEdgeOnPlane(myclass;
theE : Edge from TopoDS;
theF : Face from TopoDS;
theC2D: out Curve from Geom2d;
bToUpdate: out Boolean);
BuildPCurveForEdgesOnPlane(myclass;
theLE : ListOfShape from BOPCol;
theF : Face from TopoDS);
@@ -167,18 +179,8 @@ is
--- Make P-Curve <aC> for the edge <aE> on surface <aF> .
--- [aFirst, aLast] - range of the P-Curve
--- [aToler] - reached tolerance
---
--- Raises exception Standard_ConstructionError if algorithm fails
MakeCurveOnSurface (myclass;
aE: Edge from TopoDS;
aF: Face from TopoDS;
aC : out Curve from Geom2d;
aFirst: out Real from Standard;
aLast : out Real from Standard;
aToler: out Real from Standard);
---Purpose:
--- Same as Make2D()
---
MakePCurveOnFace (myclass;
aF: Face from TopoDS;
C3D : Curve from Geom;
@@ -187,7 +189,8 @@ is
---Purpose:
--- Make P-Curve <aC> for the 3D-curve <C3D> on surface <aF> .
--- [aToler] - reached tolerance
---
--- Raises exception Standard_ConstructionError if projection algorithm fails
MakePCurveOnFace (myclass;
aF: Face from TopoDS;
C3D : Curve from Geom;
@@ -199,7 +202,8 @@ is
--- Make P-Curve <aC> for the 3D-curve <C3D> on surface <aF> .
--- [aT1, aT2] - range to build
--- [aToler] - reached tolerance
---
--- Raises exception Standard_ConstructionError if projection algorithm fails
MakePCurveOfType (myclass;
PC : ProjectedCurve from ProjLib;
aC : out Curve from Geom2d);

View File

@@ -15,6 +15,7 @@
#include <BOPTools_AlgoTools2D.ixx>
#include <Standard_NotImplemented.hxx>
#include <Standard_ConstructionError.hxx>
#include <Precision.hxx>
#include <gp.hxx>
@@ -504,6 +505,21 @@ void BOPTools_AlgoTools2D::BuildPCurveForEdgeOnPlane
aBB.UpdateEdge(aE, aC2D, aF, aTolE);
}
}
//=======================================================================
//function : BuildPCurveForEdgeOnPlane
//purpose :
//=======================================================================
void BOPTools_AlgoTools2D::BuildPCurveForEdgeOnPlane
(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
Handle(Geom2d_Curve)& aC2D,
Standard_Boolean& bToUpdate)
{
Standard_Real aT1, aT2;
aC2D=BRep_Tool_CurveOnSurface(aE, aF, aT1, aT2, bToUpdate);
}
//=======================================================================
// function: BuildPCurveForEdgesOnPlane
// purpose:
@@ -652,6 +668,12 @@ void BOPTools_AlgoTools2D::MakePCurveOnFace
aTolR = aProj3.GetTolerance();
}
}
//
if(aC2D.IsNull())
{
Standard_ConstructionError::Raise("BOPTools_AlgoTools2D::MakePCurveOnFace : PCurve is Null");
}
//
TolReached2d=aTolR;
BOPTools_AlgoTools2D::AdjustPCurveOnFace (aBAS, aT1, aT2,
aC2D, aC2DA);

View File

@@ -85,13 +85,14 @@ Standard_Integer BOPTools_AlgoTools2D::AttachExistingPCurve
//
bIsToReverse=IsToReverse(aE2, aE1, aCtx);
if (bIsToReverse) {
Standard_Real aT21r, aT22r;
//
aC2DoldC->Reverse();
//
gp_Pnt2d aP1, aP2;
//
aC2Dold->D0(aT22, aP2);
aC2DoldC->D0(aT21, aP1);
aC2DoldC->Translate(aP1, aP2);
aT21r=aC2DoldC->ReversedParameter(aT21);
aT22r=aC2DoldC->ReversedParameter(aT22);
aT21=aT22r;
aT22=aT21r;
}
//
aC2DT=new Geom2d_TrimmedCurve(aC2DoldC, aT21, aT22);

View File

@@ -111,7 +111,7 @@ static
static
Standard_Real IntersectCurves2d(const gp_Pnt& aPV,
const TopoDS_Face& aF,
const Handle(Geom_Surface)& aS,
const GeomAdaptor_Surface& aS,
const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2);
@@ -558,7 +558,7 @@ void CorrectWires(const TopoDS_Face& aFx)
aT=BRep_Tool::Parameter(aV, aE);
//
aC2D->D0(aT, aP2D);
aS->D0(aP2D.X(), aP2D.Y(), aP);
aGAS.D0(aP2D.X(), aP2D.Y(), aP);
aD2=aPV.SquareDistance(aP);
if (aD2>aD2max) {
aD2max=aD2;
@@ -586,7 +586,7 @@ void CorrectWires(const TopoDS_Face& aFx)
continue;
}
//
aD2=IntersectCurves2d(aPV, aF, aS, aE, aE1);
aD2=IntersectCurves2d(aPV, aF, aGAS, aE, aE1);
if (aD2>aD2max) {
aD2max=aD2;
}
@@ -606,7 +606,7 @@ void CorrectWires(const TopoDS_Face& aFx)
//=======================================================================
Standard_Real IntersectCurves2d(const gp_Pnt& aPV,
const TopoDS_Face& aF,
const Handle(Geom_Surface)& aS,
const GeomAdaptor_Surface& aGAS,
const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2)
{
@@ -650,7 +650,7 @@ Standard_Real IntersectCurves2d(const gp_Pnt& aPV,
}
//
aP2D = aPoint.Value();
aS->D0(aP2D.X(), aP2D.Y(), aP);
aGAS.D0(aP2D.X(), aP2D.Y(), aP);
aD=aPV.SquareDistance(aP);
if (aD > aDist) {
aDist = 1.01 * aD;

View File

@@ -337,22 +337,24 @@ Handle(Geom2d_Curve) BRep_Tool::CurveOnSurface(const TopoDS_Edge& E,
return nullPCurve;
}
aCurveLocation = L.Predivided(aCurveLocation);
aCurveLocation = aCurveLocation.Predivided(L);
First = f; Last = l; //Range of edge must not be modified
Handle(Geom_Plane) Plane = GP;
if (!aCurveLocation.IsIdentity())
{
const gp_Trsf& T = aCurveLocation.Transformation();
Handle(Geom_Geometry) GPT = GP->Transformed(T);
Plane = *((Handle(Geom_Plane)*)&GPT);
Handle(Geom_Geometry) GC3d = C3d->Transformed(T);
C3d = *((Handle(Geom_Curve)*)&GC3d);
f = C3d->TransformedParameter(f, T);
l = C3d->TransformedParameter(l, T);
}
GeomAdaptor_Surface& GAS = HS->ChangeSurface();
GAS.Load(Plane);
GAS.Load(GP);
Handle(Geom_Curve) ProjOnPlane =
GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,f,l,Standard_True,Standard_False),
Plane,
Plane->Position().Direction(),
GP,
GP->Position().Direction(),
Standard_True);
GeomAdaptor_Curve& GAC = HC->ChangeCurve();
@@ -366,7 +368,7 @@ Handle(Geom2d_Curve) BRep_Tool::CurveOnSurface(const TopoDS_Edge& E,
(*((Handle(Geom2d_TrimmedCurve)*)&pc));
pc = TC->BasisCurve();
}
First = f; Last = l;
return pc;
}

View File

@@ -209,8 +209,13 @@ void BRepBuilderAPI_Collect::Add (const TopoDS_Shape& SI,
TopTools_DataMapOfShapeShape ModBack;
BuildBack (myGen, GenBack); // Vraiment pas optimum a Revoir
BuildBack (myMod, ModBack);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_COMPOUND);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_COMPSOLID);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_SOLID);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_SHELL);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_FACE);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_WIRE);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_EDGE);
Update (myMod,myGen,ModBack,GenBack,SI,MKS,TopAbs_VERTEX);

Some files were not shown because too many files have changed in this diff Show More