OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0026765: Visualization - drop TKVoxel toolkit

Browse Source
This commit is contained in:
kgv 2015-10-10 22:17:37 +03:00 committed by bugmaster
parent 06562706d2
commit 6ce0df1e78
97 changed files with 3 additions and 15361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adm/MODULES
View File

@ -1,7 +1,7 @@
FoundationClasses TKernel TKMath
ModelingData TKG2d TKG3d TKGeomBase TKBRep
ModelingAlgorithms TKGeomAlgo TKTopAlgo TKPrim TKBO TKBool TKHLR TKFillet TKOffset TKFeat TKMesh TKXMesh TKShHealing
Visualization TKService TKV3d TKOpenGl TKMeshVS TKVoxel TKIVtk
Visualization TKService TKV3d TKOpenGl TKMeshVS TKIVtk
ApplicationFramework TKCDF TKLCAF TKCAF TKBinL TKXmlL TKBin TKXml FWOSPlugin TKTObj TKBinTObj TKXmlTObj
DataExchange TKXSBase TKSTEPBase TKSTEPAttr TKSTEP209 TKSTEP TKIGES TKXCAF TKXDEIGES TKXDESTEP TKSTL TKVRML TKXmlXCAF TKBinXCAF
Draw TKDraw TKTopTest TKViewerTest TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw TKIVtkDraw DRAWEXE

2
adm/UDLIST
View File

@ -212,7 +212,6 @@ n StdPrs
n StdSelect
n TColQuantity
n V3d
n Voxel
n WNT
n Xw
n Cocoa
@ -223,7 +222,6 @@ t TKOpenGl
t TKD3DHost
t TKService
t TKV3d
t TKVoxel
n BinTObjDrivers
n LDOM
n TObj

1
dox/FILES_HTML.txt
View File

@ -35,7 +35,6 @@ user_guides/brep_wp/brep_wp.md
user_guides/ocaf_functionmechanism_wp/ocaf_functionmechanism_wp.md
user_guides/ocaf_tree_wp/ocaf_tree_wp.md
user_guides/ocaf_wp/ocaf_wp.md
user_guides/voxels_wp/voxels_wp.md
user_guides/vis/vis.md
dev_guides/dev_guides.md

1
dox/FILES_PDF.txt
View File

@ -19,7 +19,6 @@ user_guides/step/step.md
user_guides/draw_test_harness/draw_test_harness.md
user_guides/tobj/tobj.md
user_guides/visualization/visualization.md
user_guides/voxels_wp/voxels_wp.md
user_guides/xde/xde.md
user_guides/vis/vis.md

2
dox/dev_guides/tests/tests.md
View File

@ -987,7 +987,7 @@ This group allows testing extended data exchange packages.
| Foundation Classes | TKernel, TKMath | fclasses |
| Modeling_algorithms | TKGeomAlgo, TKTopAlgo, TKPrim, TKBO, TKBool, TKHLR, TKFillet, TKOffset, TKFeat, TKXMesh | modalg |
| Modeling Data | TKG2d, TKG3d, TKGeomBase, TKBRep | moddata |
| Visualization | TKService, TKV2d, TKV3d, TKOpenGl, TKMeshVS, TKNIS, TKVoxel | vis |
| Visualization | TKService, TKV2d, TKV3d, TKOpenGl, TKMeshVS, TKNIS | vis |
@subsection testmanual_5_3 Recommended approaches to checking test results

7
dox/overview/overview.md
View File

@ -556,13 +556,6 @@ The combination of these resources allows creating substantial applications.
**See also:** @ref occt__tutorial "OCCT Tutorial"
Voxel
------
This is a demonstration application showing OCCT voxel models. It also includes a set of non-regression tests and other commands for testing this functionality (accessible only through TEST pre-processor definition).
**See also:** <a href="occt_voxels_wp.html">Voxels User's guide</a>
**Remarks:**
* Qt samples are available on all supported platforms;

4
dox/technical_overview/technical_overview.md
View File

@ -208,10 +208,6 @@ For more details see @ref occt_user_guides__visualization "Visualization User's
The visualization of OCCT topological shapes by means of VTK library provided by VIS component is described in a separate @ref occt_user_guides__vis "VTK Integration Services" User's Guide.
Open CASCADE Technology also supports voxel representation providing basic data containers and visualization of voxels as colored or grayscale bricks.
See @ref occt_user_guides__voxels_wp "Voxels User's Guide" for more information.
See also: our <a href="http://www.opencascade.com/content/tutorial-learning">E-learning & Training</a> offerings.

1
dox/user_guides/user_guides.md
View File

@ -10,7 +10,6 @@ OCCT User Guides are organized by OCCT modules:
* @subpage occt_user_guides__boolean_operations "Boolean Operations"
* @subpage occt_user_guides__shape_healing "Shape Healing"
* @subpage occt_user_guides__visualization "Visualization"
* @subpage occt_user_guides__voxels_wp "Voxels"
* @subpage occt_user_guides__vis "VTK Integration Services"
* Data Exchange
* @subpage occt_user_guides__iges "IGES translator"

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image003.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 9.3 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image004.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 72 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image005.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 128 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image006.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 110 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image007.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 61 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image008.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 29 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image009.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 20 KiB

BIN
dox/user_guides/voxels_wp/images/voxels_wp_image010.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.1 KiB

158
dox/user_guides/voxels_wp/voxels_wp.md
View File

@ -1,158 +0,0 @@
Voxel Package {#occt_user_guides__voxels_wp}
========================
@tableofcontents
@section occt_voxels_wp_1 Introduction
A voxel is a sub-volume box with constant scalar/vector value.
The object in voxel representation is split into many small sub-volumes (voxels)
and its properties are distributed through voxels.
Voxels are used for analysis and visualization of 3D-dimensional distribution of data.
Medicine (mainly, tomography), computational physics (hydrodynamics, aerodynamics, nuclear physics)
and many other industries use voxels for 3D data visualization and analysis of physical processes.
To produce a voxel representation the 3D space is split by equal intervals
along the main orthogonal coordinate axes to obtain nx x ny x nz voxels (small cubes):
@image html voxels_wp_image003.png "A cube of 3 X 3 X 3  = 9 voxels."
@image latex voxels_wp_image003.png "A cube of 3 X 3 X 3  = 9 voxels."
The data are attached to each voxel and remain the same within the voxel.
It means that we obtain the 3D space with discrete data distribution.
The number of voxels used in a calculation can vary.
An average model contains several tens of millions of voxels.
Such a great amount of data requires special algorithms of computation,
data containers keeping data in memory and visualization tools.
Open CASCADE Technology provides several basic data containers for voxels
with fast access to the data and optimal allocation of data in memory.
Also, a special visualization toolkit allows visualizing voxels
as colored or black/white points and cubes, displaying only the voxels
visible from the user's point of view.
@image html voxels_wp_image004.png "A shape and its voxel representation"
@image html voxels_wp_image005.png "A shape and its voxel representation"
@image latex voxels_wp_image004.png "A shape and its voxel representation"
@image latex voxels_wp_image005.png "A shape and its voxel representation"
In these images a boundary representation is displayed to the left. In the center and to the right there are 3D discrete representations (or 3D discrete topology). Any solid shape can be translated into a voxel representation.
@section occt_voxels_wp_2 Data structure
The data structure to store the voxels data is a special class which gives
fast access to the data of each voxel and allocates the data in an optimal way in the memory of a computer.
Fast access to the data is provided by means of bit-wise operators on the indices of internal arrays.
The optimal data allocation is reached through division
of the whole data set into data subsets and keeping only non-zero pieces of data in memory.
A voxel can contain different data types, 
but presently Open CASCADE Technology implements only several basic ones:
* 1 bit or Boolean data type – a voxel contains a flag: 0 or 1 (false or true).
* 4 bits or Color data type – a voxel contains a value occupying 4 bits.
It is an integer in the range of 0 .. 15. The data can be divided into 16 subsets and displayed by Color-voxels.
* 4 bytes or Float data type – a voxel contains a floating-point data type.
In addition, the data structures provide methods for calculation of a center point
by voxel indices and a reverse task – fast search of a voxel by a point inside the cube of voxels.
@section occt_voxels_wp_3 Algorithms
There are two service classes implemented for data structures of voxels:
* Boolean operations – provides simple boolean operations on cubes of voxels (fuse and cut).
* Voxelization – the conversion of a geometrical model into its voxel representation.
### Boolean operations
Fusion and cutting of two cubes of voxels are performed the class *Voxel_BooleanOperations*. The cubes should have the same size and be split into voxels in the same way.
* <i>\::Fuse()</i> summarizes the values of the corresponding voxels and limits the result by the upper limit (if succeeded).
* <i>\::Cut()</i> subtracts the values of the corresponding voxels and limits the result by zero.
### Voxelization
A class *Voxel_Convert* converts a *TopoDS_Shape* into one of the voxel data structures filling the solid shape by non-zero values.
The algorithm of voxelization generates only 1-bit or 4-bit voxels. Other data types may be obtained by conversion of voxels from one type to another.
Voxelization of a shape is performed by means of computation of intersection points between lines filling the volume and triangulation of the shape. The lines are parallel to main orthogonal axes and can intersect the shape from different sides: along +X, +Y and/or +Z axes.
The algorithm can run in multi-threaded mode (the number of threads is unlimited). The user can see an integer value indicating the progress of computation.
@section occt_voxels_wp_4 Visualization
Visualization of voxels is not a simple task due to a great amount of data used for 3D analysis.
Open CASCADE Technology allows visualization of a cube of voxels in two modes:
* Points – the centers of voxels as 3D points.
* Boxes – the voxels as 3D cubes of adjustable size.
A degenerated mode displays only the points (boxes) visible
from the point of view of the user for transformation operations (zoom, pan and rotate).
To focus on a particular part of the model non-relevant voxels can be erased.
The displayed region is defined by six co-ordinates along X, Y and Z axes .
It is possible to display the voxels from a particular range of values (iso-volume):
@image html voxels_wp_image006.png "Iso-volume of a shape"
@image latex voxels_wp_image006.png "Iso-volume of a shape"
The voxels are displayed by means of "direct drawing in Open GL" technology or "user draw" technology. Therefore, some visualization files are compiled within Open CASCADE Technology, but the files of "direct drawing" are compiled  by the end-user application.
It is necessary to include the files *Voxel_VisData.h*, *VoxelClient_VisDrawer.h* and *VoxelClient_VisDrawer.cxx* into the visualization library of the application (containing all files of *OpenGl* package) and call the method *Voxel_VisDrawer::Init()* from the application before the visualization of voxels.
@section occt_voxels_wp_5 Demo-application
A demonstration application has been created to show OCCT voxel models.
This is a test demo application because it includes a set of non-regression tests
and other commands for testing the functionality (accessible only through TEST pre-processor definition).
The *File* menu allows creation of canonical shapes (box, cylinder, sphere, torus) or loading of shapes in BREP format:
@image html voxels_wp_image007.png "Demo-application. Creation or loading of a shape"
@image latex voxels_wp_image007.png "Demo-application. Creation or loading of a shape"
The menu *Converter* voxelizes the shape. Two types of voxels can be obtained: 1-bit or 4-bit voxels.
* 1-bit voxels are displayed in white color on black background.
* 4-bit voxels use 16 colors filling the model in a special way for demonstrative purposes:
@image html voxels_wp_image008.png "Demo-application. Voxelization"
@image latex voxels_wp_image008.png "Demo-application. Voxelization"
The converter uses two threads (two processors, if available) to perform voxelization.
The menu *Visualization* offers two modes of visualization: Points and Boxes,
allows defining the size of points and boxes (quadrangles),
the minimum and the maximum displayed color, and the boundaries of the bounding box for displayed voxels:
@image html voxels_wp_image009.png "Demo-application. Visualization"
@image latex voxels_wp_image009.png "Demo-application. Visualization"
The last menu, *Demo* contains a demo-command for running waves of 4-bit voxels:
@image html voxels_wp_image010.png "Demo-application. Running waves"
@image latex voxels_wp_image010.png "Demo-application. Running waves"
@section occt_voxels_wp_6 Future development
In the future OPEN CASCADE plans to develop the platform of voxels in the following directions:
* Data structure:
* Extension of the list of basic data types.
* Development of a deeper hierarchy of voxels (for example, octree – division of a voxel into 8 sub-voxels).
* Development of a doxel (4D voxels where the fourth co-ordinate is the time, for example).
* Algorithms:
* Conversion of a voxel model into a geometrical model (a reversed operation to voxelization).
* Visualization:
* Optimization of visualization (mainly, the speed of visualization).
* New shapes of voxel presentation in the 3D Viewer and new approaches to visualization.
* Selection of voxels.

26
samples/qt/VoxelDemo/VoxelDemo-vc10.sln
View File

@ -1,26 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VoxelDemo", "VoxelDemo.vcxproj", "{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}"
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
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Debug|Win32.ActiveCfg = Debug|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Debug|Win32.Build.0 = Debug|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Debug|x64.ActiveCfg = Debug|x64
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Debug|x64.Build.0 = Debug|x64
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Release|Win32.ActiveCfg = Release|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Release|Win32.Build.0 = Release|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Release|x64.ActiveCfg = Release|x64
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

26
samples/qt/VoxelDemo/VoxelDemo-vc12.sln
View File

@ -1,26 +0,0 @@

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

20
samples/qt/VoxelDemo/VoxelDemo-vc9.sln
View File

@ -1,20 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VoxelDemo", "VoxelDemo.vcproj", "{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Debug|Win32.ActiveCfg = Debug|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Debug|Win32.Build.0 = Debug|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Release|Win32.ActiveCfg = Release|Win32
{EF9DFAE9-E10E-42D4-87D1-52431728AFDF}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

185
samples/qt/VoxelDemo/VoxelDemo.pro
View File

@ -1,185 +0,0 @@
TEMPLATE = app
CONFIG += debug_and_release qt opengl
TARGET = VoxelDemo
SAMPLESROOT = $$(CASROOT)/samples/qt
HEADERS = $${SAMPLESROOT}/voxeldemo/inc/*.h
SOURCES = $${SAMPLESROOT}/voxeldemo/src/*.cxx \
$${SAMPLESROOT}/voxeldemo/src/*.cpp
INCLUDEPATH += $$quote($${SAMPLESROOT}/voxeldemo/inc)
DEFINES =
unix {
UNAME = $$system(uname -s)
INCLUDES = $$(CSF_OPT_INC)
PATHS = $$split(INCLUDES,":")
for(path, PATHS):INCLUDEPATH += $${path}
LIBLIST = $$(LD_LIBRARY_PATH)
LIBPATHS = $$split(LIBLIST,":")
for(lib, LIBPATHS):LIBS += -L$${lib}
CONFIG(debug, debug|release) {
DESTDIR = ./$$UNAME/bind
OBJECTS_DIR = ./$$UNAME/objd
MOC_DIR = ./$$UNAME/srcd
} else {
DESTDIR = ./$$UNAME/bin
OBJECTS_DIR = ./$$UNAME/obj
MOC_DIR = ./$$UNAME/src
}
MACOSX_USE_GLX = $$(MACOSX_USE_GLX)
!macx | equals(MACOSX_USE_GLX, true): INCLUDEPATH += $$QMAKE_INCDIR_X11 $$QMAKE_INCDIR_OPENGL $$QMAKE_INCDIR_THREAD
!macx | equals(MACOSX_USE_GLX, true): DEFINES += LIN LININTEL
equals(MACOSX_USE_GLX, true): DEFINES += MACOSX_USE_GLX
DEFINES += OCC_CONVERT_SIGNALS QT_NO_STL
!macx | equals(MACOSX_USE_GLX, true): LIBS += -L$$QMAKE_LIBDIR_X11 $$QMAKE_LIBS_X11 -L$$QMAKE_LIBDIR_OPENGL $$QMAKE_LIBS_OPENGL $$QMAKE_LIBS_THREAD
LIBS += -lfreeimageplus
LIBS += -ltbb -ltbbmalloc
}
win32 {
INCLUDES = $$(CSF_OPT_INC)
PATHS = $$split(INCLUDES,";")
for(path, PATHS):INCLUDEPATH += $${path}
CONFIG(debug, debug|release) {
DEFINES += _DEBUG
!contains(QMAKE_HOST.arch, x86_64) {
LIBS = -L$(CSF_OPT_LIB32D)
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1310) {
DESTDIR = ./win32/vc7/bind
OBJECTS_DIR = ./win32/vc7/objd
MOC_DIR = ./win32/vc7/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1400) {
DESTDIR = ./win32/vc8/bind
OBJECTS_DIR = ./win32/vc8/objd
MOC_DIR = ./win32/vc8/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1500) {
DESTDIR = ./win32/vc9/bind
OBJECTS_DIR = ./win32/vc9/objd
MOC_DIR = ./win32/vc9/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1600) {
DESTDIR = ./win32/vc10/bind
OBJECTS_DIR = ./win32/vc10/objd
MOC_DIR = ./win32/vc10/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1700) {
DESTDIR = ./win32/vc11/bind
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) {
DESTDIR = ./win64/vc8/bind
OBJECTS_DIR = ./win64/vc8/objd
MOC_DIR = ./win64/vc8/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1500) {
DESTDIR = ./win64/vc9/bind
OBJECTS_DIR = ./win64/vc9/objd
MOC_DIR = ./win64/vc9/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1600) {
DESTDIR = ./win64/vc10/bind
OBJECTS_DIR = ./win64/vc10/objd
MOC_DIR = ./win64/vc10/srcd
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1700) {
DESTDIR = ./win64/vc11/bind
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
!contains(QMAKE_HOST.arch, x86_64) {
LIBS = -L$(CSF_OPT_LIB32)
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1310) {
DESTDIR = ./win32/vc7/bin
OBJECTS_DIR = ./win32/vc7/obj
MOC_DIR = ./win32/vc7/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1400) {
DESTDIR = ./win32/vc8/bin
OBJECTS_DIR = ./win32/vc8/obj
MOC_DIR = ./win32/vc8/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1500) {
DESTDIR = ./win32/vc9/bin
OBJECTS_DIR = ./win32/vc9/obj
MOC_DIR = ./win32/vc9/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1600) {
DESTDIR = ./win32/vc10/bin
OBJECTS_DIR = ./win32/vc10/obj
MOC_DIR = ./win32/vc10/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1700) {
DESTDIR = ./win32/vc11/bin
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) {
DESTDIR = ./win64/vc8/bin
OBJECTS_DIR = ./win64/vc8/obj
MOC_DIR = ./win64/vc8/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1500) {
DESTDIR = ./win64/vc9/bin
OBJECTS_DIR = ./win64/vc9/obj
MOC_DIR = ./win64/vc9/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1600) {
DESTDIR = ./win64/vc10/bin
OBJECTS_DIR = ./win64/vc10/obj
MOC_DIR = ./win64/vc10/src
}
contains(QMAKE_COMPILER_DEFINES, _MSC_VER=1700) {
DESTDIR = ./win64/vc11/bin
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
}
LIBS += -lTKernel -lTKMath -lTKService -lTKV3d \
-lTKBRep -lTKGeomBase -lTKTopAlgo -lTKPrim \
-lTKBool -lTKVoxel -lTKOpenGl \
QMAKE_CXXFLAGS = -Zc:wchar_t

43
samples/qt/VoxelDemo/genproj.bat
View File

@ -1,43 +0,0 @@
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

116
samples/qt/VoxelDemo/inc/Application.h
View File

@ -1,116 +0,0 @@
#ifndef APPLICATION_H
#define APPLICATION_H
#include <qmainwindow.h>
#include <AIS_ColorScale.hxx>
#include <AIS_Shape.hxx>
#include <Voxel_Prs.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_ColorDS.hxx>
#include "Viewer.h"
class Application: public QMainWindow
{
Q_OBJECT
public:
Application();
~Application();
protected:
void closeEvent( QCloseEvent* );
private slots:
void box();
void cylinder();
void torus();
void sphere();
void choose();
void load( const QString & );
void load( const TopoDS_Shape & );
void save();
void open();
void testBoolDS();
void testColorDS();
void testFloatDS();
void testOctBoolDS();
void testROctBoolDS();
void testFuseBoolDS();
void testFuseColorDS();
void testFuseFloatDS();
void testCutBoolDS();
void testCutColorDS();
void testCutFloatDS();
void convert2bool();
void convert2color();
void convert(const int );
void setNbX();
void setNbY();
void setNbZ();
void setScanSide();
void setVolumicBoolValue();
void setVolumicColorValue();
void setQuadrangleSize();
void setPointSize();
void setColorMinValue();
void setColorMaxValue();
void setUsageOfGLlists();
void setDisplayedXMin();
void setDisplayedXMax();
void setDisplayedYMin();
void setDisplayedYMax();
void setDisplayedZMin();
void setDisplayedZMax();
void displayPoints();
void displayNearestPoints();
void displayBoxes();
void displayNearestBoxes();
void displayColorScale();
void displayWaves();
void displayCut();
void displayCollisions();
void about();
private:
void display(Voxel_VoxelDisplayMode );
void initPrs();
Viewer* myViewer;
Handle(AIS_Shape) myShape;
Handle(Voxel_Prs) myVoxels;
Voxel_BoolDS* myBoolVoxels;
Voxel_ColorDS* myColorVoxels;
Handle(AIS_ColorScale) myColorScale;
int myNbX;
int myNbY;
int myNbZ;
unsigned char myScanSide;
bool myVolumicBoolValue;
unsigned char myVolumicColorValue;
int myQuadrangleSize;
int myPointSize;
unsigned char myColorMinValue;
unsigned char myColorMaxValue;
double myDisplayedXMin;
double myDisplayedXMax;
double myDisplayedYMin;
double myDisplayedYMax;
double myDisplayedZMin;
double myDisplayedZMax;
};
#endif // APPLICATION_H

40
samples/qt/VoxelDemo/inc/ConversionThread.h
View File

@ -1,40 +0,0 @@
#ifndef _CONVERSIONTHREAD_H_
#define _CONVERSIONTHREAD_H_
#include <QThread.h>
//#include <Voxel_Converter.hxx>
#include <Voxel_FastConverter.hxx>
class ConversionThread : public QThread
{
public:
ConversionThread();
~ConversionThread();
// void setConverter(Voxel_Converter* converter);
void setConverter(Voxel_FastConverter* converter);
void setVolumicValue(const int value);
void setScanSide(const int side);
void setThreadIndex(const int ithread);
int* getProgress();
protected:
void run();
private:
// Voxel_Converter* myConverter;
Voxel_FastConverter* myFastConverter;
int myVolumicValue;
int myScanSide;
int myThreadIndex;
int myProgress;
};
#endif // _CONVERSIONTHREAD_H_

33
samples/qt/VoxelDemo/inc/Timer.h
View File

@ -1,33 +0,0 @@
// Timer.h: interface for the Timer class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_TIMER_H__528FB454_797E_11D7_9B1B_000103C0F1F9__INCLUDED_)
#define AFX_TIMER_H__528FB454_797E_11D7_9B1B_000103C0F1F9__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <OSD_Timer.hxx>
class Timer
{
public:
Standard_EXPORT Timer();
Standard_EXPORT Timer(const char* filename);
Standard_EXPORT ~Timer();
Standard_EXPORT void Start();
Standard_EXPORT void Stop();
Standard_EXPORT void Continue();
Standard_EXPORT void Reset();
Standard_EXPORT float Seconds();
Standard_EXPORT int Minutes();
Standard_EXPORT void Print(char* label);
private:
OSD_Timer myTimer;
FILE* myWriter;
};
#endif // !defined(AFX_TIMER_H__528FB454_797E_11D7_9B1B_000103C0F1F9__INCLUDED_)

67
samples/qt/VoxelDemo/inc/Viewer.h
View File

@ -1,67 +0,0 @@
#ifndef _VIEWER_H_
#define _VIEWER_H_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <QWidget.h>
#include <AIS_InteractiveContext.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <V3d_View.hxx>
#include <OpenGl_View.hxx>
#include <Voxel_Prs.hxx>
#include <Voxel_Selector.hxx>
class Viewer : public QWidget
{
Q_OBJECT
public:
Viewer(QWidget* parent);
virtual ~Viewer();
Handle(AIS_InteractiveContext) getIC() const { return myIC; }
Handle(V3d_View) getView() const { return myView; }
Handle(OpenGl_GraphicDriver) getGraphicDriver() const { return myGraphicDriver; }
Voxel_Selector& getSelector() { return mySelector; }
void setPrs(const Handle(Voxel_Prs)& prs) { myPrs = prs; }
virtual QPaintEngine* paintEngine() const;
signals:
void mousePressed(Qt::KeyboardModifiers,int,int);
void mouseMoved(Qt::KeyboardModifiers,int,int);
void mouseReleased(Qt::KeyboardModifiers,int,int);
void mouseDoubleClick(Qt::KeyboardModifiers,int,int);
protected:
virtual void paintEvent(QPaintEvent* pEvent);
virtual void resizeEvent(QResizeEvent* rsEvent);
virtual void mousePressEvent(QMouseEvent* mpEvent);
virtual void mouseMoveEvent(QMouseEvent* mmEvent);
virtual void mouseReleaseEvent(QMouseEvent* mrEvent);
virtual void mouseDoubleClickEvent(QMouseEvent* mdcEvent);
private:
Handle(AIS_InteractiveContext) myIC;
Handle(V3d_View) myView;
Handle(OpenGl_GraphicDriver) myGraphicDriver;
bool myRotate;
bool myZoom;
bool myPan;
QPoint myStartPnt;
void setDegenerateMode(const bool );
Voxel_Selector mySelector;
Handle(Voxel_Prs) myPrs;
};
#endif // _VIEWER_H_

74
samples/qt/VoxelDemo/inc/VoxelClient_VisDrawer.h
View File

@ -1,74 +0,0 @@
/*
Copyright (c) 1999-2014 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 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.
*/
#ifndef _VOXEL_VISDRAWER_H_
#define _VOXEL_VISDRAWER_H_
#include "Voxel_VisData.h"
#include <Graphic3d_BndBox4f.hxx>
#include <Voxel_Prs.hxx>
//! Voxel presentation using UserDraw.
class VoxelClient_PrsGl : public Voxel_Prs
{
public:
//! Empty constructor.
VoxelClient_PrsGl() {}
protected:
//! Override compute to create UserDraw element.
Standard_EXPORT virtual void Compute (const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
const Handle(Prs3d_Presentation)& thePrs,
const Standard_Integer theMode) Standard_OVERRIDE;
public:
DEFINE_STANDARD_RTTI(VoxelClient_PrsGl, Voxel_Prs)
};
DEFINE_STANDARD_HANDLE(VoxelClient_PrsGl, Voxel_Prs)
class VoxelClient_VisDrawer
{
public:
class VisElement;
public:
Standard_EXPORT VoxelClient_VisDrawer(Voxel_VisData* theData);
Standard_EXPORT virtual ~VoxelClient_VisDrawer();
Standard_EXPORT void EvalMinMax(Graphic3d_BndBox4f& theMinMax) const;
Standard_EXPORT void Display(const Standard_Boolean theHighlight);
private:
Standard_EXPORT void DisplayVoxels(const Standard_Boolean theHighlight);
Standard_EXPORT void DisplayPoints(const Standard_Boolean nearest);
Standard_EXPORT void DisplayBoxes(const Standard_Boolean nearest);
Standard_EXPORT void HighlightVoxel();
Standard_EXPORT void DisplayTriangulation(const Standard_Boolean theHighlight);
Voxel_VisData* myData;
};
#endif // _VOXEL_VISDRAWER_H_

38
samples/qt/VoxelDemo/msvc.bat
View File

@ -1,38 +0,0 @@
@echo off
rem Setup environment
call "%~dp0..\..\..\env.bat" %1 %2 %3
rem Define path to project file
set "PRJFILE=%~dp0VoxelDemo-%VCVER%.sln"
set "VisualStudioExpressName=VCExpress"
if "%VCVER%" == "vc8" (
set "DevEnvDir=%VS80COMNTOOLS%..\IDE"
) else if "%VCVER%" == "vc9" (
set "DevEnvDir=%VS90COMNTOOLS%..\IDE"
) else if "%VCVER%" == "vc10" (
set "DevEnvDir=%VS100COMNTOOLS%..\IDE"
) else if "%VCVER%" == "vc11" (
set "DevEnvDir=%VS110COMNTOOLS%..\IDE"
rem Visual Studio Express starting from VS 2012 is called "for Windows Desktop"
rem and has a new name for executable - WDExpress
set "VisualStudioExpressName=WDExpress"
) else if "%VCVER%" == "vc12" (
set "DevEnvDir=%VS120COMNTOOLS%..\IDE"
set "VisualStudioExpressName=WDExpress"
) else (
echo Error: wrong VS identifier
exit /B
)
rem Launch Visual Studio - either professional (devenv) or Express, as available
if exist "%DevEnvDir%\devenv.exe" (
start "%DevEnvDir%\devenv.exe" "%PRJFILE%"
) else if exist "%DevEnvDir%\%VisualStudioExpressName%.exe" (
start "%DevEnvDir%\%VisualStudioExpressName%.exe" "%PRJFILE%"
) else (
echo Error: Could not find MS Visual Studio ^(%VCVER%^)
echo Check relevant environment variable ^(e.g. VS80COMNTOOLS for vc8^)
)

21
samples/qt/VoxelDemo/run.bat
View File

@ -1,21 +0,0 @@
call "%~dp0..\..\..\env.bat" %1 %2 %3
set "BIN_DIR=win%ARCH%\%VCVER%\bind"
if ["%CASDEB%"] == [""] (
set "BIN_DIR=win%ARCH%\%VCVER%\bin"
)
if not exist "%~dp0%BIN_DIR%\VoxelDemo.exe" goto ERR_EXE
echo Starting VoxelDemo .....
"%~dp0%BIN_DIR%\VoxelDemo.exe"
goto END
:ERR_EXE
echo Executable %~dp0%BIN_DIR%\VoxelDemo.exe not found.
echo Probably you didn't compile the application.
pause
goto END
:END

2343
samples/qt/VoxelDemo/src/Application.cpp
View File

File diff suppressed because it is too large Load Diff

58
samples/qt/VoxelDemo/src/ConversionThread.cpp
View File

@ -1,58 +0,0 @@
#include "ConversionThread.h"
ConversionThread::ConversionThread():QThread(),
/*myConverter(0),*/myFastConverter(0),
myVolumicValue(0),myScanSide(1),
myThreadIndex(1)
{
}
ConversionThread::~ConversionThread()
{
}
/*
void ConversionThread::setConverter(Voxel_Converter* converter)
{
myConverter = converter;
myFastConverter = 0;
}
*/
void ConversionThread::setConverter(Voxel_FastConverter* converter)
{
myFastConverter = converter;
//myConverter = 0;
}
void ConversionThread::setVolumicValue(const int value)
{
myVolumicValue = value;
}
void ConversionThread::setScanSide(const int side)
{
myScanSide = side;
}
void ConversionThread::setThreadIndex(const int ithread)
{
myThreadIndex = ithread;
}
int* ConversionThread::getProgress()
{
return &myProgress;
}
void ConversionThread::run()
{
if (/*!myConverter && */!myFastConverter)
return;
//if (myConverter)
// myConverter->Convert(myProgress, myVolumicValue, myScanSide, myThreadIndex);
//else
myFastConverter->Convert(myProgress, myThreadIndex);
}

13
samples/qt/VoxelDemo/src/Main.cpp
View File

@ -1,13 +0,0 @@
#include <qapplication.h>
#include "application.h"
int main( int argc, char ** argv )
{
QApplication a( argc, argv );
Application *w = new Application();
w->setWindowTitle( "Voxel demo-application" );
w->show();
a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
return a.exec();
}

67
samples/qt/VoxelDemo/src/Timer.cpp
View File

@ -1,67 +0,0 @@
// Timer.cpp: implementation of the Timer class.
//
//////////////////////////////////////////////////////////////////////
#include "Timer.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Timer::Timer():myWriter(0) {}
Timer::Timer(const char* filename)
{
fopen_s(&myWriter,filename, "a");
}
Timer::~Timer()
{
if (myWriter)
fclose(myWriter);
}
void Timer::Start() {
myTimer.Reset();
myTimer.Start();
}
void Timer::Stop() {
myTimer.Stop();
}
void Timer::Continue() {
myTimer.Start();
}
void Timer::Reset() {
myTimer.Reset();
}
float Timer::Seconds() {
Standard_Real sec, cpu;
Standard_Integer minutes, hours;
myTimer.Show(sec, minutes, hours, cpu);
return (float) sec;
}
int Timer::Minutes() {
Standard_Real sec, cpu;
Standard_Integer minutes, hours;
myTimer.Show(sec, minutes, hours, cpu);
return minutes;
}
void Timer::Print(char* label) {
Standard_Real seconds, cpu;
Standard_Integer minutes, hours;
myTimer.Show(seconds, minutes, hours, cpu);
if (myWriter)
{
fprintf(myWriter, "%s took %d minutes %g seconds\n", label, minutes, seconds);
}
else
{
cout<<label<<" took "<<minutes<<" minutes, "<<seconds<<" seconds"<<endl;
}
}

213
samples/qt/VoxelDemo/src/Viewer.cpp
View File

@ -1,213 +0,0 @@
#include "Viewer.h"
#include "Timer.h"
#include <QApplication.h>
#include <QCursor.h>
#include <QMessagebox.h>
#include <QMouseEvent>
#include <WNT_Window.hxx>
#include <Voxel_Prs.hxx>
#include <AIS_ListOfInteractive.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
#include <Aspect_DisplayConnection.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <V3d_DirectionalLight.hxx>
#include <V3d_AmbientLight.hxx>
static Handle(Graphic3d_GraphicDriver) Viewer_aGraphicDriver;
Viewer::Viewer(QWidget* parent):QWidget(parent)
{
if (myGraphicDriver.IsNull())
{
if (Viewer_aGraphicDriver.IsNull())
{
Handle(Aspect_DisplayConnection) aDisplayConnection;
Viewer_aGraphicDriver = new OpenGl_GraphicDriver (aDisplayConnection);
}
myGraphicDriver = Handle(OpenGl_GraphicDriver)::DownCast(Viewer_aGraphicDriver);
}
Handle(V3d_Viewer) aViewer = new V3d_Viewer(myGraphicDriver, TCollection_ExtendedString("Visu3D").ToExtString(), "",
1000, V3d_XposYnegZpos,
Quantity_NOC_GRAY30, V3d_ZBUFFER, V3d_GOURAUD, V3d_WAIT,
true, true, V3d_TEX_NONE);
aViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
myView = aViewer->CreateView();
myIC = new AIS_InteractiveContext(aViewer);
myIC->SetDeviationCoefficient(1.e-3);
Aspect_Handle aWindowHandle = (Aspect_Handle )winId();
Handle(WNT_Window) hWnd = new WNT_Window (aWindowHandle);
myView->SetWindow(hWnd);
if(!hWnd->IsMapped())
hWnd->Map();
myView->MustBeResized();
myView->SetSurfaceDetail(V3d_TEX_NONE);
myView->SetSize(10000.0);
myView->SetZSize(10000.0);
myView->SetViewMappingDefault();
myZoom = false;
myPan = false;
myRotate = false;
setMouseTracking(true);
setMinimumSize(400, 200);
myView->ZBufferTriedronSetup();
myView->TriedronDisplay(Aspect_TOTP_LEFT_LOWER, Quantity_NOC_BLACK, 0.1, V3d_ZBUFFER);
mySelector.Init(myView);
setBackgroundRole( QPalette::NoRole );//NoBackground );
// set focus policy to threat QContextMenuEvent from keyboard
setFocusPolicy( Qt::StrongFocus );
setAttribute( Qt::WA_PaintOnScreen );
setAttribute( Qt::WA_NoSystemBackground );
aViewer->SetLightOn(new V3d_DirectionalLight(aViewer, V3d_XnegYnegZneg, Quantity_NOC_WHITE, Standard_True));
aViewer->SetLightOn(new V3d_AmbientLight(aViewer, Quantity_NOC_WHITE));
}
Viewer::~Viewer()
{
}
void Viewer::paintEvent(QPaintEvent * pEvent)
{
if (!myView.IsNull())
myView->Redraw();
}
/*!
Get paint engine for the OpenGL viewer. [ virtual public ]
*/
QPaintEngine* Viewer::paintEngine() const
{
return 0;
}
void Viewer::resizeEvent(QResizeEvent * e)
{
if (!myView.IsNull())
{
myView->MustBeResized();
}
}
void Viewer::mousePressEvent(QMouseEvent * mpEvent)
{
// Memorize start point
myStartPnt.setX(mpEvent->x());
myStartPnt.setY(mpEvent->y());
// Inform IC that the mouse cursor is at the point
myIC->MoveTo(myStartPnt.x(), myStartPnt.y(), myView);
// In case of rotation, define the start rotation point
if ((mpEvent->modifiers() & Qt::ControlModifier) && (mpEvent->buttons() & Qt::RightButton))
{
myView->StartRotation(myStartPnt.x(), myStartPnt.y());
}
// Start degenerate mode
setDegenerateMode(true);
emit mousePressed(mpEvent->modifiers(), mpEvent->x(), mpEvent->y());
}
void Viewer::mouseMoveEvent(QMouseEvent * mmEvent)
{
QPoint currentPnt(mmEvent->x(), mmEvent->y());
if (mmEvent->modifiers() & Qt::ControlModifier)
{
if (mmEvent->buttons() & Qt::LeftButton)
{
myView->Zoom(myStartPnt.x(), myStartPnt.y(), currentPnt.x(), currentPnt.y());
myStartPnt = currentPnt;
}
else if (mmEvent->buttons() & Qt::MidButton)
{
myView->Pan(currentPnt.x() - myStartPnt.x(), myStartPnt.y() - currentPnt.y());
myStartPnt = currentPnt;
}
else if (mmEvent->buttons() & Qt::RightButton)
{
myView->Rotation(currentPnt.x(), currentPnt.y());
}
}
else
{
myIC->MoveTo(currentPnt.x(), currentPnt.y(), myView);
}
emit mouseMoved(mmEvent->modifiers(), currentPnt.x(), currentPnt.y());
}
void Viewer::mouseReleaseEvent(QMouseEvent * mrEvent)
{
if(mrEvent->button() == Qt::LeftButton)
{
if(!myZoom && !myPan && !myRotate)
{
if(mrEvent->modifiers() & Qt::ShiftModifier)
myIC->ShiftSelect();
else
myIC->Select();
// Select a voxel
int ix = -1, iy = -1, iz = -1;
bool detected = mySelector.Detect(mrEvent->x(), mrEvent->y(), ix, iy, iz);
if (detected)
{
cout<<"("<<ix<<", "<<iy<<", "<<iz<<")"<<endl;
}
if (!myPrs.IsNull())
myPrs->Highlight(ix, iy, iz);
}
}
else if(mrEvent->button() == Qt::RightButton)
{
// Popup menu:
}
// Finish degenerate mode
setDegenerateMode(false);
emit mouseReleased(mrEvent->modifiers(), mrEvent->x(), mrEvent->y());
}
void Viewer::mouseDoubleClickEvent(QMouseEvent * mdcEvent)
{
emit mouseDoubleClick(mdcEvent->modifiers(), mdcEvent->x(), mdcEvent->y());
}
void Viewer::setDegenerateMode(const bool on)
{
AIS_ListOfInteractive displayed;
myIC->DisplayedObjects(displayed);
AIS_ListIteratorOfListOfInteractive itri(displayed);
for (; itri.More(); itri.Next())
{
Handle(Voxel_Prs) prs = Handle(Voxel_Prs)::DownCast(itri.Value());
if (!prs.IsNull())
{
prs->SetDegenerateMode(on);
myView->Redraw();
break;
}
}
}

3374
samples/qt/VoxelDemo/src/VoxelClient_VisDrawer.cxx
View File

File diff suppressed because it is too large Load Diff

3
src/OS/Visualization.tcl
View File

@ -18,8 +18,7 @@ proc Visualization:toolkits { } {
set aResult [list TKService \
TKV3d \
TKOpenGl \
TKMeshVS \
TKVoxel]
TKMeshVS]
if { [info exists ::env(HAVE_VTK)] && "$::env(HAVE_VTK)" == "true" } {
lappend aResult "TKIVtk"

77
src/QABugs/QABugs_19.cxx
View File

@ -691,53 +691,6 @@ static Standard_Integer OCC23945 (Draw_Interpretor& /*di*/,Standard_Integer n, c
return 0;
}
#include <Voxel_BoolDS.hxx>
#include <Voxel_FastConverter.hxx>
#include <Voxel_BooleanOperation.hxx>
static Standard_Integer OCC24019 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
if ( argc != 2 ) {
di << "Error: " << argv[0] << " - invalid number of arguments" << "\n";
return 1;
}
TCollection_AsciiString aFileName = argv[1];
TopoDS_Shape aShape;
BRep_Builder aBuilder;
if (!BRepTools::Read(aShape, aFileName.ToCString(), aBuilder)) {
di << "Error: Could not read a shape!" << "\n";
return 1;
}
TopoDS_Solid aShape1 = BRepPrimAPI_MakeSphere(gp_Pnt(20,25,35), 7);
Standard_Real deflection = 0.005;
Standard_Integer nbThreads = 1;
Standard_Integer nbx = 200, nby = 200, nbz = 200;
Voxel_BoolDS theVoxels(0,0,0, 50, 50, 50, nbx, nby, nbz);
Voxel_BoolDS theVoxels1(0,0,0, 50, 50, 50, nbx, nby, nbz);
Standard_Integer progress = 0;
Voxel_FastConverter fcp(aShape, theVoxels, deflection, nbx, nby, nbz, nbThreads);
fcp.ConvertUsingSAT(progress, 1);
fcp.FillInVolume(1);
Voxel_FastConverter fcp1(aShape1, theVoxels1, deflection, nbx, nby, nbz, nbThreads);
fcp1.ConvertUsingSAT(progress, 1);
fcp1.FillInVolume(1);
Voxel_BooleanOperation op;
Standard_Boolean result = op.Cut(theVoxels1, theVoxels);
if ( result != 1 ) {
di << "Error: invalid boolean operation" << "\n";
} else {
di << "OK: boolean operation is ok" << "\n";
}
return 0;
}
//=======================================================================
//function : OCC11758
//purpose :
@ -1331,34 +1284,6 @@ static Standard_Integer OCC24012 (Draw_Interpretor& di, Standard_Integer argc, c
return 0;
}
#include <Voxel_FastConverter.hxx>
static Standard_Integer OCC24051 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
{
if (argc != 1) {
di << "Usage : " << argv[0] << " should be one argument (command name only)";
return 1;
}
TopoDS_Shape shape = BRepPrimAPI_MakeBox(gp_Pnt(5, 10, 10), 10, 20, 30).Shape();
Standard_Integer progress = 0;
Standard_Real deflection = 0.005;
Standard_Integer nbx = 200, nby = 200, nbz = 200;
Voxel_BoolDS theVoxels(-50,-50,-30, 100, 100, 100, nbx, nby, nbz);
Voxel_BoolDS theVoxels1(-50,-50,-30, 100, 100, 100, nbx, nby, nbz);
Standard_Integer nbThreads = 5;
Voxel_FastConverter fcp(shape, theVoxels, deflection, nbx, nby, nbz, nbThreads, Standard_True);
#ifdef _MSC_VER
#pragma omp parallel for
for(int i = 0; i < nbThreads; i++)
fcp.ConvertUsingSAT(progress, i+1);
#endif
fcp.ConvertUsingSAT(progress);
return 0;
}
#include <BRepFeat_SplitShape.hxx>
#include <ShapeAnalysis_ShapeContents.hxx>
#include <BRepAlgo.hxx>
@ -4635,7 +4560,6 @@ void QABugs::Commands_19(Draw_Interpretor& theCommands) {
theCommands.Add ("test_offset", "test_offset", __FILE__, test_offset, group);
theCommands.Add ("OCC23945", "OCC23945 surfname U V X Y Z [DUX DUY DUZ DVX DVY DVZ [D2UX D2UY D2UZ D2VX D2VY D2VZ D2UVX D2UVY D2UVZ]]", __FILE__, OCC23945,group);
theCommands.Add ("OCC24008", "OCC24008 curve surface", __FILE__, OCC24008, group);
theCommands.Add ("OCC24019", "OCC24019 aShape", __FILE__, OCC24019, group);
theCommands.Add ("OCC11758", "OCC11758", __FILE__, OCC11758, group);
theCommands.Add ("OCC24005", "OCC24005 result", __FILE__, OCC24005, group);
theCommands.Add ("OCC24137", "OCC24137 face vertex U V [N]", __FILE__, OCC24137, group);
@ -4644,7 +4568,6 @@ void QABugs::Commands_19(Draw_Interpretor& theCommands) {
theCommands.Add ("OCC24370", "OCC24370 edge pcurve surface prec", __FILE__, OCC24370, group);
theCommands.Add ("OCC24533", "OCC24533", __FILE__, OCC24533, group);
theCommands.Add ("OCC24012", "OCC24012 face edge", __FILE__, OCC24012, group);
theCommands.Add ("OCC24051", "OCC24051", __FILE__, OCC24051, group);
theCommands.Add ("OCC24086", "OCC24086 face wire", __FILE__, OCC24086, group);
theCommands.Add ("OCC24622", "OCC24622 texture={1D|2D}\n Tests sourcing of 1D/2D pixmaps for AIS_TexturedShape", __FILE__, OCC24622, group);
theCommands.Add ("OCC24667", "OCC24667 result Wire_spine Profile [Mode [Approx]], no args to get help", __FILE__, OCC24667, group);

1
src/TKQADraw/EXTERNLIB
View File

@ -31,7 +31,6 @@ TKSTEPBase
TKXDESTEP
TKXSDRAW
TKSTL
TKVoxel
CSF_gdi32
CSF_advapi32
CSF_user32

1
src/TKViewerTest/EXTERNLIB
View File

@ -14,7 +14,6 @@ TKG2d
TKTopTest
TKG3d
TKOffset
TKVoxel
TKMesh
TKV3d
TKDraw

7
src/TKVoxel/CMakeLists.txt
View File

@ -1,7 +0,0 @@
project(TKVoxel)
set (TOOLKIT_MODULES
Voxel
)
OCCT_INCLUDE_CMAKE_FILE (adm/cmake/occt_toolkit)

10
src/TKVoxel/EXTERNLIB
View File

@ -1,10 +0,0 @@
TKBRep
TKernel
TKV3d
TKMath
TKService
TKGeomBase
TKG2d
TKTopAlgo
TKG3d
TKMesh

1
src/TKVoxel/FILES
View File

@ -1 +0,0 @@
EXTERNLIB

1
src/TKVoxel/PACKAGES
View File

@ -1 +0,0 @@
Voxel

1
src/ViewerTest/FILES
View File

@ -16,4 +16,3 @@ ViewerTest_OpenGlCommands.cxx
ViewerTest_RelationCommands.cxx
ViewerTest_ViewerCommands.cxx
ViewerTest_ViewerCommands_1.mm
ViewerTest_VoxelCommands.cxx

1
src/ViewerTest/ViewerTest.cxx
View File

@ -5467,7 +5467,6 @@ void ViewerTest::Commands(Draw_Interpretor& theCommands)
ViewerTest::RelationCommands(theCommands);
ViewerTest::ObjectCommands(theCommands);
ViewerTest::FilletCommands(theCommands);
ViewerTest::VoxelCommands(theCommands);
ViewerTest::OpenGlCommands(theCommands);
const char *group = "AIS_Display";

2
src/ViewerTest/ViewerTest.hxx
View File

@ -130,8 +130,6 @@ public:
Standard_EXPORT static void FilletCommands (Draw_Interpretor& theCommands);
Standard_EXPORT static void VoxelCommands (Draw_Interpretor& theCommands);
Standard_EXPORT static void OpenGlCommands (Draw_Interpretor& theCommands);
Standard_EXPORT static void GetMousePosition (Standard_Integer& xpix, Standard_Integer& ypix);

1053
src/ViewerTest/ViewerTest_VoxelCommands.cxx
View File

File diff suppressed because it is too large Load Diff

32
src/Voxel/FILES
View File

@ -1,32 +0,0 @@
Voxel_BoolDS.cxx
Voxel_BoolDS.hxx
Voxel_BooleanOperation.cxx
Voxel_BooleanOperation.hxx
Voxel_CollisionDetection.cxx
Voxel_CollisionDetection.hxx
Voxel_ColorDS.cxx
Voxel_ColorDS.hxx
Voxel_DS.cxx
Voxel_DS.hxx
Voxel_FastConverter.cxx
Voxel_FastConverter.hxx
Voxel_FloatDS.cxx
Voxel_FloatDS.hxx
Voxel_OctBoolDS.cxx
Voxel_OctBoolDS.hxx
Voxel_Prs.cxx
Voxel_Prs.hxx
Voxel_Reader.cxx
Voxel_Reader.hxx
Voxel_ROctBoolDS.cxx
Voxel_ROctBoolDS.hxx
Voxel_Selector.cxx
Voxel_Selector.hxx
Voxel_SplitData.cxx
Voxel_SplitData.hxx
Voxel_TypeDef.hxx
Voxel_VisData.h
Voxel_VoxelDisplayMode.hxx
Voxel_VoxelFileFormat.hxx
Voxel_Writer.cxx
Voxel_Writer.hxx

141
src/Voxel/Voxel_BoolDS.cxx
View File

@ -1,141 +0,0 @@
// Created on: 2008-06-21
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Voxel_BoolDS.hxx>
#include <stdlib.h>
static Standard_Byte gbits[8] = {1, 2, 4, 8, 16, 32, 64, 128};
static Standard_Byte gnbits[8] = {255-1, 255-2, 255-4, 255-8, 255-16, 255-32, 255-64, 255-128};
// Empty constructor
Voxel_BoolDS::Voxel_BoolDS():Voxel_DS()
{
}
// Constructor with intialization.
Voxel_BoolDS::Voxel_BoolDS(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
:Voxel_DS()
{
Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
}
// Initialization.
void Voxel_BoolDS::Init(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
Destroy();
Voxel_DS::Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
if (!myNbX || !myNbY || !myNbZ)
return;
Standard_Integer nb_bytes = RealToInt(ceil(myNbXY * myNbZ / 8.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 8.0));
myData = (Standard_Address) calloc(nb_slices, sizeof(Standard_Byte*));
}
// Destructor
void Voxel_BoolDS::Destroy()
{
if (myData)
{
SetZero();
free((Standard_Byte**)myData);
myData = 0;
}
}
void Voxel_BoolDS::SetZero()
{
if (myData)
{
Standard_Integer nb_bytes = RealToInt(ceil(myNbXY * myNbZ / 8.0));
Standard_Integer ix = 0, nb_slices = RealToInt(ceil(nb_bytes / 8.0));
for (; ix < nb_slices; ix++)
{
if (((Standard_Byte**)myData)[ix])
{
free(((Standard_Byte**)myData)[ix]);
((Standard_Byte**)myData)[ix] = 0;
}
}
}
}
// Access to the boolean information attached to a particular voxel:
// Info: (ix >= 0 && ix < theNb_x), etc.
void Voxel_BoolDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Boolean data)
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 6;
if (!data && !((Standard_Byte**)myData)[islice])
return; // don't allocate a slice of data for setting a 0 value
// Allocate the slice if it is not done yet.
if (!((Standard_Byte**)myData)[islice])
{
((Standard_Byte**)myData)[islice] = (Standard_Byte*) calloc(8/*number of bytes in slice*/, sizeof(Standard_Byte));
}
// Index within 8 bytes of the slice.
Standard_Integer ibit_in_current_slice = ibit - (islice << 6);
Standard_Integer ibyte = ibit_in_current_slice >> 3;
// Value (byte)
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte];
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit_in_current_slice - (ibyte << 3);
// Set data
if (data != ((value & gbits[shift]) ? Standard_True : Standard_False))
{
if (data)
value |= gbits[shift];
else
value &= gnbits[shift];
((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte] = value;
}
}
Standard_Boolean Voxel_BoolDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 6;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Standard_Byte**)myData)[islice])
return Standard_False;
// Index within 8 bytes of the slice.
Standard_Integer ibit_in_current_slice = ibit - (islice << 6);
Standard_Integer ibyte = ibit_in_current_slice >> 3;
// Value (byte)
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte];
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit_in_current_slice - (ibyte << 3);
return ((value & gbits[shift]) ? Standard_True : Standard_False);
}

96
src/Voxel/Voxel_BoolDS.hxx
View File

@ -1,96 +0,0 @@
// Created on: 2008-05-04
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_BoolDS_HeaderFile
#define _Voxel_BoolDS_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Voxel_DS.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! A 3D voxel model keeping a bool flag (1 or 0)
//! value for each voxel.
class Voxel_BoolDS : public Voxel_DS
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_BoolDS();
//! A constructor initializing the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT Voxel_BoolDS(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
//! Initialization of the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT virtual void Init (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z) Standard_OVERRIDE;
//! A destructor of the voxel model.
Standard_EXPORT void Destroy();
~Voxel_BoolDS()
{
Destroy();
}
//! The method sets all values equal to 0 (false) and
//! releases the memory.
Standard_EXPORT void SetZero();
//! Defines a value for voxel with co-ordinates (ix, iy, iz).
//! Initial state of the model is so that all voxels have value 0 (false),
//! and this data doesn't occupy memory.
//! Memory for data is allocating during setting non-zero values (true).
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Boolean data = Standard_True);
//! Returns the value of voxel with co-ordinates (ix, iy, iz).
Standard_EXPORT Standard_Boolean Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
protected:
private:
};
#endif // _Voxel_BoolDS_HeaderFile

230
src/Voxel/Voxel_BooleanOperation.cxx
View File

@ -1,230 +0,0 @@
// Created on: 2008-05-21
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Precision.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_BooleanOperation.hxx>
#include <Voxel_ColorDS.hxx>
#include <Voxel_DS.hxx>
#include <Voxel_FloatDS.hxx>
Voxel_BooleanOperation::Voxel_BooleanOperation()
{
}
Standard_Boolean Voxel_BooleanOperation::Fuse( Voxel_BoolDS& theVoxels1,
const Voxel_BoolDS& theVoxels2) const
{
// Check the voxels
if (!Check(theVoxels1, theVoxels2))
return Standard_False;
// Take the values of the second cube and put them to the first one.
Standard_Integer ix, iy, iz;
for (iz = 0; iz < theVoxels2.GetNbZ(); iz++)
{
for (iy = 0; iy < theVoxels2.GetNbY(); iy++)
{
for (ix = 0; ix < theVoxels2.GetNbX(); ix++)
{
Standard_Boolean value2 = theVoxels2.Get(ix, iy, iz);
if (value2)
theVoxels1.Set(ix, iy, iz, value2);
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_BooleanOperation::Fuse( Voxel_ColorDS& theVoxels1,
const Voxel_ColorDS& theVoxels2) const
{
// Check the voxels
if (!Check(theVoxels1, theVoxels2))
return Standard_False;
// Take the values of the second cube and put them to the first one.
Standard_Integer ix, iy, iz;
for (iz = 0; iz < theVoxels2.GetNbZ(); iz++)
{
for (iy = 0; iy < theVoxels2.GetNbY(); iy++)
{
for (ix = 0; ix < theVoxels2.GetNbX(); ix++)
{
Standard_Byte value2 = theVoxels2.Get(ix, iy, iz);
if (value2)
{
Standard_Byte value1 = theVoxels1.Get(ix, iy, iz);
Standard_Byte value = value1 + value2;
if (value > 15)
value = 15;
theVoxels1.Set(ix, iy, iz, value);
}
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_BooleanOperation::Fuse( Voxel_FloatDS& theVoxels1,
const Voxel_FloatDS& theVoxels2) const
{
// Check the voxels
if (!Check(theVoxels1, theVoxels2))
return Standard_False;
// Take the values of the second cube and put them to the first one.
Standard_Integer ix, iy, iz;
for (iz = 0; iz < theVoxels2.GetNbZ(); iz++)
{
for (iy = 0; iy < theVoxels2.GetNbY(); iy++)
{
for (ix = 0; ix < theVoxels2.GetNbX(); ix++)
{
Standard_ShortReal value2 = theVoxels2.Get(ix, iy, iz);
if (value2)
{
Standard_ShortReal value1 = theVoxels1.Get(ix, iy, iz);
theVoxels1.Set(ix, iy, iz, value1 + value2);
}
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_BooleanOperation::Cut( Voxel_BoolDS& theVoxels1,
const Voxel_BoolDS& theVoxels2) const
{
// Check the voxels
if (!Check(theVoxels1, theVoxels2))
return Standard_False;
// Subtract the values.
Standard_Integer ix, iy, iz;
for (iz = 0; iz < theVoxels2.GetNbZ(); iz++)
{
for (iy = 0; iy < theVoxels2.GetNbY(); iy++)
{
for (ix = 0; ix < theVoxels2.GetNbX(); ix++)
{
Standard_Boolean value1 = theVoxels1.Get(ix, iy, iz);
if (value1)
{
Standard_Boolean value2 = theVoxels2.Get(ix, iy, iz);
if (value2)
theVoxels1.Set(ix, iy, iz, Standard_False);
}
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_BooleanOperation::Cut( Voxel_ColorDS& theVoxels1,
const Voxel_ColorDS& theVoxels2) const
{
// Check the voxels
if (!Check(theVoxels1, theVoxels2))
return Standard_False;
// Subtract the values.
Standard_Integer ix, iy, iz;
for (iz = 0; iz < theVoxels2.GetNbZ(); iz++)
{
for (iy = 0; iy < theVoxels2.GetNbY(); iy++)
{
for (ix = 0; ix < theVoxels2.GetNbX(); ix++)
{
Standard_Byte value2 = theVoxels2.Get(ix, iy, iz);
if (value2)
{
Standard_Byte value1 = theVoxels1.Get(ix, iy, iz);
if (value1)
{
Standard_Integer value = value1 - value2;
if (value < 0)
value = 0;
theVoxels1.Set(ix, iy, iz, (Standard_Byte)value);
}
}
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_BooleanOperation::Cut( Voxel_FloatDS& theVoxels1,
const Voxel_FloatDS& theVoxels2) const
{
// Check the voxels
if (!Check(theVoxels1, theVoxels2))
return Standard_False;
// Subtract the values.
Standard_Integer ix, iy, iz;
for (iz = 0; iz < theVoxels2.GetNbZ(); iz++)
{
for (iy = 0; iy < theVoxels2.GetNbY(); iy++)
{
for (ix = 0; ix < theVoxels2.GetNbX(); ix++)
{
Standard_ShortReal value2 = theVoxels2.Get(ix, iy, iz);
if (value2)
{
Standard_ShortReal value1 = theVoxels1.Get(ix, iy, iz);
theVoxels1.Set(ix, iy, iz, value1 - value2);
}
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_BooleanOperation::Check(const Voxel_DS& theVoxels1,
const Voxel_DS& theVoxels2) const
{
// Check the voxels
// Number of splits along X, Y and Z axes.
if (!theVoxels1.GetNbX() && theVoxels1.GetNbX() != theVoxels2.GetNbX())
return Standard_False;
if (!theVoxels1.GetNbY() && theVoxels1.GetNbY() != theVoxels2.GetNbY())
return Standard_False;
if (!theVoxels1.GetNbZ() && theVoxels1.GetNbZ() != theVoxels2.GetNbZ())
return Standard_False;
// Start point
if (fabs(theVoxels1.GetX() - theVoxels2.GetX()) > Precision::Confusion() ||
fabs(theVoxels1.GetY() - theVoxels2.GetY()) > Precision::Confusion() ||
fabs(theVoxels1.GetZ() - theVoxels2.GetZ()) > Precision::Confusion())
{
return Standard_False;
}
// Length along X, Y and Z axes.
if (fabs(theVoxels1.GetXLen() - theVoxels2.GetXLen()) > Precision::Confusion() ||
fabs(theVoxels1.GetYLen() - theVoxels2.GetYLen()) > Precision::Confusion() ||
fabs(theVoxels1.GetZLen() - theVoxels2.GetZLen()) > Precision::Confusion())
{
return Standard_False;
}
return Standard_True;
}

108
src/Voxel/Voxel_BooleanOperation.hxx
View File

@ -1,108 +0,0 @@
// Created on: 2008-05-21
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_BooleanOperation_HeaderFile
#define _Voxel_BooleanOperation_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
class Voxel_BoolDS;
class Voxel_ColorDS;
class Voxel_FloatDS;
class Voxel_DS;
//! Boolean operations (fuse, cut)
//! for voxels of the same dimension.
class Voxel_BooleanOperation
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_BooleanOperation();
//! Fuses two cubes of voxels.
//! It modifies the first cube of voxels.
//! It returns false in case of different dimension of the cube,
//! different number of voxels.
Standard_EXPORT Standard_Boolean Fuse (Voxel_BoolDS& theVoxels1, const Voxel_BoolDS& theVoxels2) const;
//! Fuses two cubes of voxels.
//! It modifies the first cube of voxels.
//! It returns false in case of different dimension of the cube,
//! different number of voxels.
//! It summerizes the value of corresponding voxels and puts the result to theVoxels1.
//! If the result exceeds 15 or becomes greater, it keeps 15.
Standard_EXPORT Standard_Boolean Fuse (Voxel_ColorDS& theVoxels1, const Voxel_ColorDS& theVoxels2) const;
//! Fuses two cubes of voxels.
//! It modifies the first cube of voxels.
//! It returns false in case of different dimension of the cube,
//! different number of voxels.
//! It summerizes the value of corresponding voxels and puts the result to theVoxels1.
Standard_EXPORT Standard_Boolean Fuse (Voxel_FloatDS& theVoxels1, const Voxel_FloatDS& theVoxels2) const;
//! Cuts two cubes of voxels.
//! It modifies the first cube of voxels.
//! It returns false in case of different dimension of the cube,
//! different number of voxels.
Standard_EXPORT Standard_Boolean Cut (Voxel_BoolDS& theVoxels1, const Voxel_BoolDS& theVoxels2) const;
//! Cuts two cubes of voxels.
//! It modifies the first cube of voxels.
//! It returns false in case of different dimension of the cube,
//! different number of voxels.
//! It subtracts the value of corresponding voxels and puts the result to theVoxels1.
Standard_EXPORT Standard_Boolean Cut (Voxel_ColorDS& theVoxels1, const Voxel_ColorDS& theVoxels2) const;
//! Cuts two cubes of voxels.
//! It modifies the first cube of voxels.
//! It returns false in case of different dimension of the cube,
//! different number of voxels.
//! It subtracts the value of corresponding voxels and puts the result to theVoxels1.
Standard_EXPORT Standard_Boolean Cut (Voxel_FloatDS& theVoxels1, const Voxel_FloatDS& theVoxels2) const;
protected:
private:
Standard_EXPORT Standard_Boolean Check (const Voxel_DS& theVoxels1, const Voxel_DS& theVoxels2) const;
};
#endif // _Voxel_BooleanOperation_HeaderFile

295
src/Voxel/Voxel_CollisionDetection.cxx
View File

@ -1,295 +0,0 @@
// Created on: 2008-07-16
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Bnd_Box.hxx>
#include <BRepBndLib.hxx>
#include <Precision.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_CollisionDetection.hxx>
#include <Voxel_FastConverter.hxx>
Voxel_CollisionDetection::Voxel_CollisionDetection()
:myDeflection(0.1),
myNbX(100),
myNbY(100),
myNbZ(100),
myUsageOfVolume(Standard_False),
myKeepCollisions(Standard_False),
myXLen(-1.0),
myYLen(-1.0),
myZLen(-1.0),
myVoxels(0),
myHasCollisions(Standard_False)
{
}
Voxel_CollisionDetection::Voxel_CollisionDetection(const Standard_Real deflection,
const Standard_Integer nbx,
const Standard_Integer nby,
const Standard_Integer nbz)
:myDeflection(deflection),
myNbX(nbx),
myNbY(nby),
myNbZ(nbz),
myUsageOfVolume(Standard_False),
myKeepCollisions(Standard_False),
myXLen(-1.0),
myYLen(-1.0),
myZLen(-1.0),
myVoxels(0),
myHasCollisions(Standard_False)
{
}
// Destructor
void Voxel_CollisionDetection::Destroy()
{
Clear();
}
Standard_Integer Voxel_CollisionDetection::AddShape(const TopoDS_Shape& shape)
{
Clear();
myShapes.Append(shape);
return myShapes.Extent();
}
Standard_Boolean Voxel_CollisionDetection::ReplaceShape(const Standard_Integer ishape,
const TopoDS_Shape& shape)
{
if (ishape == 1)
{
myShapes.RemoveFirst();
myShapes.Prepend(shape);
return Standard_True;
}
Standard_Integer i = 1;
Standard_Boolean is_replaced = Standard_False;
TopTools_ListIteratorOfListOfShape itr(myShapes);
for (; itr.More(); itr.Next(), i++)
{
if (i == ishape)
{
myShapes.Remove(itr);
myShapes.InsertBefore(shape, itr);
is_replaced = Standard_True;
break;
}
}
return is_replaced;
}
void Voxel_CollisionDetection::SetDeflection(const Standard_Real deflection)
{
myDeflection = deflection;
}
void Voxel_CollisionDetection::SetNbVoxels(const Standard_Integer nbx,
const Standard_Integer nby,
const Standard_Integer nbz)
{
myNbX = nbx;
myNbY = nby;
myNbZ = nbz;
}
void Voxel_CollisionDetection::SetBoundaryBox(const Bnd_Box& box)
{
if (box.IsVoid())
return;
Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
box.Get(xmin, ymin, zmin, xmax, ymax, zmax);
myX = xmin;
myY = ymin;
myZ = zmin;
myXLen = xmax - xmin;
myYLen = ymax - ymin;
myZLen = zmax - zmin;
}
void Voxel_CollisionDetection::SetUsageOfVolume(const Standard_Boolean usage)
{
myUsageOfVolume = usage;
}
void Voxel_CollisionDetection::KeepCollisions(const Standard_Boolean keep)
{
myKeepCollisions = keep;
}
Standard_Boolean Voxel_CollisionDetection::Voxelize(const Standard_Integer ishape)
{
// Check the arguments
if (myNbX <= 0 || myNbY <= 0 || myNbZ <= 0)
return Standard_False;
// Calculate the boundary box of the shapes to define the size of voxels.
// This code is called only if the user didn't define the boundary box himself.
if (myXLen < 0.0)
{
Bnd_Box B, b;
TopTools_ListIteratorOfListOfShape itrs(myShapes);
for (; itrs.More(); itrs.Next())
{
TopoDS_Shape S = itrs.Value();
BRepBndLib::Add(S, b);
B.Add(b);
}
SetBoundaryBox(B);
}
// Voxelize the shapes
Standard_Integer progress, ithread = 1, i = 1;
TopTools_ListIteratorOfListOfShape itrs(myShapes);
for (; itrs.More(); itrs.Next(), i++)
{
if (ishape != -1 && i != ishape)
continue;
if (!myVoxels)
myVoxels = (Standard_Address) new Voxel_BoolDS[myShapes.Extent()];
Voxel_BoolDS& voxels = ((Voxel_BoolDS*)myVoxels)[i - 1];
if (!CheckVoxels(voxels))
{
voxels.Init(myX, myY, myZ, myXLen, myYLen, myZLen, myNbX, myNbY, myNbZ);
}
else
{
voxels.SetZero();
}
TopoDS_Shape S = itrs.Value();
Voxel_FastConverter voxelizer(S, voxels, myDeflection, myNbX, myNbY, myNbZ, 1 /*number of threads */);
if (!voxelizer.Convert(progress, ithread))
return Standard_False;
if (myUsageOfVolume && !voxelizer.FillInVolume(1, ithread))
return Standard_False;
}
return Standard_True;
}
Standard_Boolean Voxel_CollisionDetection::Compute()
{
myHasCollisions = Standard_False;
// Check voxels of shapes
if (!myVoxels)
return Standard_False;
Standard_Integer ishape = 0, nb_shapes = myShapes.Extent();
for (; ishape < nb_shapes; ishape++)
{
Voxel_BoolDS& voxels = ((Voxel_BoolDS*)myVoxels)[ishape];
if (!CheckVoxels(voxels))
{
return Standard_False;
}
}
// Check the resulting voxels
Standard_Boolean created = Standard_False;
if (!CheckVoxels(myCollisions))
{
// Create 0-voxels for the result, if it is needed.
created = Standard_True;
myCollisions.Init(myX, myY, myZ, myXLen, myYLen, myZLen, myNbX, myNbY, myNbZ);
}
// Nullify the voxels of the result (it corresponds to the state of no collisions).
if (!myKeepCollisions && !created)
{
myCollisions.SetZero();
}
// Check collisions
if (nb_shapes)
{
Standard_Integer ix, iy, iz;
Voxel_BoolDS& voxels = ((Voxel_BoolDS*)myVoxels)[0]; // 1st shape
for (ix = 0; ix < myNbX; ix++)
{
for (iy = 0; iy < myNbY; iy++)
{
for (iz = 0; iz < myNbZ; iz++)
{
if (voxels.Get(ix, iy, iz))
{
for (ishape = 1; ishape < nb_shapes; ishape++) // start with second shape
{
Voxel_BoolDS& anOtherVoxels = ((Voxel_BoolDS*)myVoxels)[ishape];
if (anOtherVoxels.Get(ix, iy, iz))
{
myCollisions.Set(ix, iy, iz, Standard_True);
if (!myHasCollisions)
{
myHasCollisions = Standard_True;
}
break;
}
}
}
}
}
}
}
return Standard_True;
}
Standard_Boolean Voxel_CollisionDetection::HasCollisions() const
{
return myHasCollisions;
}
const Voxel_BoolDS& Voxel_CollisionDetection::GetCollisions() const
{
return myCollisions;
}
void Voxel_CollisionDetection::Clear()
{
if (myVoxels)
{
delete[] ((Voxel_BoolDS*)myVoxels);
myVoxels = 0;
}
}
Standard_Boolean Voxel_CollisionDetection::CheckVoxels(const Voxel_BoolDS& voxels) const
{
if (fabs(voxels.GetX() - myX) > Precision::Confusion() ||
fabs(voxels.GetY() - myY) > Precision::Confusion() ||
fabs(voxels.GetZ() - myZ) > Precision::Confusion() ||
fabs(voxels.GetXLen() - myXLen) > Precision::Confusion() ||
fabs(voxels.GetYLen() - myYLen) > Precision::Confusion() ||
fabs(voxels.GetZLen() - myZLen) > Precision::Confusion() ||
voxels.GetNbX() != myNbX ||
voxels.GetNbY() != myNbY ||
voxels.GetNbZ() != myNbZ)
{
return Standard_False;
}
return Standard_True;
}

151
src/Voxel/Voxel_CollisionDetection.hxx
View File

@ -1,151 +0,0 @@
// Created on: 2008-07-14
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_CollisionDetection_HeaderFile
#define _Voxel_CollisionDetection_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Address.hxx>
#include <Voxel_BoolDS.hxx>
class TopoDS_Shape;
class Bnd_Box;
class Voxel_BoolDS;
//! Detects collisions between shapes.
class Voxel_CollisionDetection
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_CollisionDetection();
//! A constructor.
//! It defines deflection of triangulation for the shapes.
//! As lower the deflection is, as proper the triangulation is generated.
//! Also, it defines number of splits along X, Y and Z axes for generation of voxels.
//! As greater the numbers are, as greater number of voxels is used for detection of collision.
Standard_EXPORT Voxel_CollisionDetection(const Standard_Real deflection, const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz);
//! Adds a shape.
//! Returns an index of the shape.
Standard_EXPORT Standard_Integer AddShape (const TopoDS_Shape& shape);
//! Replaces a shape by another one.
//! <ishape> is an index of the shape.
//! This method is useful for moving shape, for example.
Standard_EXPORT Standard_Boolean ReplaceShape (const Standard_Integer ishape, const TopoDS_Shape& shape);
//! Defines the deflection of triangulation of shapes.
Standard_EXPORT void SetDeflection (const Standard_Real deflection);
//! Defines the number of voxels along X, Y and Z axes.
Standard_EXPORT void SetNbVoxels (const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz);
//! Defines a user-defined boundary box for generation of voxels.
//! If this method is not called, the algorithm calculates the boundary box itself.
Standard_EXPORT void SetBoundaryBox (const Bnd_Box& box);
//! Defines usage of volume of shapes in collision detection algorithm.
//! Beware, usage of volume a little bit decreases the speed of algorithm.
Standard_EXPORT void SetUsageOfVolume (const Standard_Boolean usage);
//! Doesn't clean the collision points on new call to the method Compute().
//! It allows to see the collisions for a moving shape.
Standard_EXPORT void KeepCollisions (const Standard_Boolean keep);
//! Prepares data for computation of collisions.
//! It checks the inner parameters (number of voxels along X, Y and Z axes) and
//! voxelizes the shapes.
//! If the shape is not changed since the last call to this method,
//! this method may be not called for this shape.
//! <ishape> - is the index of the shape for processing by this method.
//! If it is equal to -1, all shapes will be processed.
Standard_EXPORT Standard_Boolean Voxelize (const Standard_Integer ishape = -1);
//! Computes the collisions.
//! This method may be called many times if, for example, the shapes are being moved.
Standard_EXPORT Standard_Boolean Compute();
//! Returns true if a collision is detected.
Standard_EXPORT Standard_Boolean HasCollisions() const;
//! Returns the collided voxels.
Standard_EXPORT const Voxel_BoolDS& GetCollisions() const;
//! A destructor.
Standard_EXPORT void Destroy();
~Voxel_CollisionDetection()
{
Destroy();
}
protected:
private:
//! An internal method for cleaning the intermediate data.
Standard_EXPORT void Clear();
//! An internal method, which checks correspondance
//! of voxels to the parameters defined by user.
Standard_EXPORT Standard_Boolean CheckVoxels (const Voxel_BoolDS& voxels) const;
TopTools_ListOfShape myShapes;
Standard_Real myDeflection;
Standard_Integer myNbX;
Standard_Integer myNbY;
Standard_Integer myNbZ;
Standard_Boolean myUsageOfVolume;
Standard_Boolean myKeepCollisions;
Standard_Real myX;
Standard_Real myY;
Standard_Real myZ;
Standard_Real myXLen;
Standard_Real myYLen;
Standard_Real myZLen;
Standard_Address myVoxels;
Voxel_BoolDS myCollisions;
Standard_Boolean myHasCollisions;
};
#endif // _Voxel_CollisionDetection_HeaderFile

173
src/Voxel/Voxel_ColorDS.cxx
View File

@ -1,173 +0,0 @@
// Created on: 2008-05-08
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Voxel_ColorDS.hxx>
#include <stdlib.h>
static Standard_Byte gbits[8] = {1, 2, 4, 8, 16, 32, 64, 128};
static Standard_Byte gnbits[8] = {255-1, 255-2, 255-4, 255-8, 255-16, 255-32, 255-64, 255-128};
// Empty constructor
Voxel_ColorDS::Voxel_ColorDS():Voxel_DS()
{
}
// Constructor with intialization.
Voxel_ColorDS::Voxel_ColorDS(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
:Voxel_DS()
{
Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
}
// Initialization.
void Voxel_ColorDS::Init(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
Destroy();
Voxel_DS::Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
if (!myNbX || !myNbY || !myNbZ)
return;
Standard_Integer nb_bytes = RealToInt(ceil(myNbXY * myNbZ / 2.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 32.0));
myData = (Standard_Address) calloc(nb_slices, sizeof(Standard_Byte*));
}
// Destructor
void Voxel_ColorDS::Destroy()
{
if (myData)
{
SetZero();
free((Standard_Byte**)myData);
myData = 0;
}
}
void Voxel_ColorDS::SetZero()
{
if (myData)
{
Standard_Integer nb_bytes = RealToInt(ceil(myNbXY * myNbZ / 2.0));
Standard_Integer ix = 0, nb_slices = RealToInt(ceil(nb_bytes / 32.0));
for (; ix < nb_slices; ix++)
{
if (((Standard_Byte**)myData)[ix])
{
free(((Standard_Byte**)myData)[ix]);
((Standard_Byte**)myData)[ix] = 0;
}
}
}
}
// Access to the boolean information attached to a particular voxel:
// Info: (ix >= 0 && ix < theNb_x), etc.
void Voxel_ColorDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Byte data)
{
Standard_Integer ibit = 4 * (ix + myNbX * iy + myNbXY * iz);
Standard_Integer islice = ibit >> 8;
if (!data && !((Standard_Byte**)myData)[islice])
return; // don't allocate a slice of data for setting a 0 value
// Allocate the slice if it is not done yet.
if (!((Standard_Byte**)myData)[islice])
{
((Standard_Byte**)myData)[islice] = (Standard_Byte*) calloc(32/*number of bytes in slice*/, sizeof(Standard_Byte));
}
// Index within 32 bytes of the slice.
Standard_Integer ibit_in_current_slice = ibit - (islice << 8);
Standard_Integer ibyte = ibit_in_current_slice >> 3;
// Value (byte)
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte];
// Position of data in the 8 bit-"value":
// It is either 0 (first part of the byte) or 2 (second part of the byte)
Standard_Integer shift = ibit_in_current_slice - (ibyte << 3);
// Set data
Standard_Integer i = 0, j = 0, nb = 4; // first part of byte
if (shift == 4)
{
// second part of byte
i = 4;
nb = 8;
}
for (; i < nb; i++, j++)
{
if (data & gbits[j]) // if j-th bit is 1
{
value |= gbits[i]; // set 1 to the i-th bit
}
else
{
value &= gnbits[i]; // set 0 to the i-th bit
}
}
((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte] = value;
}
Standard_Byte Voxel_ColorDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Byte ret = 0;
Standard_Integer ibit = 4 * (ix + myNbX * iy + myNbXY * iz);
Standard_Integer islice = ibit >> 8;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Standard_Byte**)myData)[islice])
return ret;
// Index within 8 bytes of the slice.
Standard_Integer ibit_in_current_slice = ibit - (islice << 8);
Standard_Integer ibyte = ibit_in_current_slice >> 3;
// Value (byte)
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte];
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit_in_current_slice - (ibyte << 3);
// Return a byte with 4 first bits filled-in by the value.
Standard_Integer i = 0, j = 0, nb = 4; // first part of byte
if (shift == 4)
{
// second part of byte
i = 4;
nb = 8;
}
for (; i < nb; i++, j++)
{
if (value & gbits[i]) // if i-th bit is 1
{
ret |= gbits[j]; // set 1 to the j-th bit
}
}
return ret;
}

96
src/Voxel/Voxel_ColorDS.hxx
View File

@ -1,96 +0,0 @@
// Created on: 2008-05-08
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_ColorDS_HeaderFile
#define _Voxel_ColorDS_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Voxel_DS.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Byte.hxx>
//! A 3D voxel model keeping 4 bits for each voxel (one of 16 colors).
class Voxel_ColorDS : public Voxel_DS
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_ColorDS();
//! A constructor initializing the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT Voxel_ColorDS(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
//! Initialization of the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT virtual void Init (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z) Standard_OVERRIDE;
//! A destructor of the voxel model.
Standard_EXPORT void Destroy();
~Voxel_ColorDS()
{
Destroy();
}
//! The method sets all values equal to 0 (false) and
//! releases the memory.
Standard_EXPORT void SetZero();
//! Defines a value for voxel with co-ordinates (ix, iy, iz).
//! Only the first four bits are used!
//! Initial state of the model is so that all voxels have value 0x0000,
//! and this data doesn't occupy memory.
//! Memory for data is allocating during setting non-zero values (0x0101, for example).
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Byte data);
//! Returns the value of voxel with co-ordinates (ix, iy, iz).
Standard_EXPORT Standard_Byte Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
protected:
private:
};
#endif // _Voxel_ColorDS_HeaderFile

194
src/Voxel/Voxel_DS.cxx
View File

@ -1,194 +0,0 @@
// Created on: 2008-05-11
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Voxel_DS.hxx>
#include <Voxel_Reader.hxx>
#include <Voxel_Writer.hxx>
// Empty constructor
Voxel_DS::Voxel_DS()
:myData(0),
myX(0.0),myY(0.0),myZ(0.0),
myXLen(0.0),myYLen(0.0),myZLen(0.0),
myNbX(0),myNbY(0),myNbZ(0),
myNbXY(0),myDX(0.0),myDY(0.0),myDZ(0.0),
myHalfDX(0.0),myHalfDY(0.0),myHalfDZ(0.0)
{
}
// Constructor with intialization.
Voxel_DS::Voxel_DS(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
}
// Initialization.
void Voxel_DS::Init(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
myX = x;
myY = y;
myZ = z;
myXLen = xlen;
myYLen = ylen;
myZLen = zlen;
myNbX = nbx;
myNbY = nby;
myNbZ = nbz;
myNbXY = myNbX * myNbY;
myDX = myXLen / (Standard_Real) myNbX;
myDY = myYLen / (Standard_Real) myNbY;
myDZ = myZLen / (Standard_Real) myNbZ;
myHalfDX = myDX / 2.0;
myHalfDY = myDY / 2.0;
myHalfDZ = myDZ / 2.0;
}
// Get the initial information on voxels
Standard_Real Voxel_DS::GetX() const
{
return myX;
}
Standard_Real Voxel_DS::GetY() const
{
return myY;
}
Standard_Real Voxel_DS::GetZ() const
{
return myZ;
}
Standard_Real Voxel_DS::GetXLen() const
{
return myXLen;
}
Standard_Real Voxel_DS::GetYLen() const
{
return myYLen;
}
Standard_Real Voxel_DS::GetZLen() const
{
return myZLen;
}
Standard_Integer Voxel_DS::GetNbX() const
{
return myNbX;
}
Standard_Integer Voxel_DS::GetNbY() const
{
return myNbY;
}
Standard_Integer Voxel_DS::GetNbZ() const
{
return myNbZ;
}
void Voxel_DS::GetCenter(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
Standard_Real& xc, Standard_Real& yc, Standard_Real& zc) const
{
GetOrigin(ix, iy, iz, xc, yc, zc);
xc += myHalfDX;
yc += myHalfDY;
zc += myHalfDZ;
}
void Voxel_DS::GetOrigin(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
Standard_Real& x0, Standard_Real& y0, Standard_Real& z0) const
{
x0 = myX + ix * myDX;
y0 = myY + iy * myDY;
z0 = myZ + iz * myDZ;
}
// The method uses a chordial approach to find the index of voxel by co-ordinate.
static Standard_Integer findIndex(const Standard_Real xstart, const Standard_Real dx,
const Standard_Integer ix1, const Standard_Integer ix2,
const Standard_Real x)
{
if (ix2 - ix1 < 2)
{
if (x < xstart + ix2 * dx)
return ix1;
return ix2;
}
// Middle index
const Standard_Integer ixm = (ix1 + ix2) / 2;
// Check if it is in the first half:
if (x >= xstart + ix1 * dx && x < xstart + ixm * dx)
{
return findIndex(xstart, dx, ix1, ixm, x);
}
return findIndex(xstart, dx, ixm, ix2, x);
}
Standard_Boolean Voxel_DS::GetVoxel(const Standard_Real x, const Standard_Real y, const Standard_Real z,
Standard_Integer& ix, Standard_Integer& iy, Standard_Integer& iz) const
{
// X
if (!GetVoxelX(x, ix))
return Standard_False;
// Y
if (!GetVoxelY(y, iy))
return Standard_False;
// Z
return GetVoxelZ(z, iz);
}
Standard_Boolean Voxel_DS::GetVoxelX(const Standard_Real x,
Standard_Integer& ix) const
{
// X
if (x < myX || x > myX + myXLen)
return Standard_False;
ix = findIndex(myX, myXLen / (Standard_Real) myNbX, 0, myNbX - 1, x);
return Standard_True;
}
Standard_Boolean Voxel_DS::GetVoxelY(const Standard_Real y,
Standard_Integer& iy) const
{
// Y
if (y < myY || y > myY + myYLen)
return Standard_False;
iy = findIndex(myY, myYLen / (Standard_Real) myNbY, 0, myNbY - 1, y);
return Standard_True;
}
Standard_Boolean Voxel_DS::GetVoxelZ(const Standard_Real z,
Standard_Integer& iz) const
{
// Z
if (z < myZ || z > myZ + myZLen)
return Standard_False;
iz = findIndex(myZ, myZLen / (Standard_Real) myNbZ, 0, myNbZ - 1, z);
return Standard_True;
}

134
src/Voxel/Voxel_DS.hxx
View File

@ -1,134 +0,0 @@
// Created on: 2008-05-07
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_DS_HeaderFile
#define _Voxel_DS_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Voxel_Writer;
class Voxel_Reader;
//! A base class for all voxel data structures.
class Voxel_DS
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_DS();
//! A constructor initializing the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT Voxel_DS(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
//! Initialization of the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
//! The methods below return initial data of the voxel model.
Standard_EXPORT virtual void Init (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
Standard_EXPORT Standard_Real GetX() const;
Standard_EXPORT Standard_Real GetY() const;
Standard_EXPORT Standard_Real GetZ() const;
Standard_EXPORT Standard_Real GetXLen() const;
Standard_EXPORT Standard_Real GetYLen() const;
Standard_EXPORT Standard_Real GetZLen() const;
Standard_EXPORT Standard_Integer GetNbX() const;
Standard_EXPORT Standard_Integer GetNbY() const;
Standard_EXPORT Standard_Integer GetNbZ() const;
//! Returns the center point of a voxel with co-ordinates (ix, iy, iz).
Standard_EXPORT void GetCenter (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, Standard_Real& xc, Standard_Real& yc, Standard_Real& zc) const;
//! Returns the origin point of a voxel with co-ordinates (ix, iy, iz).
Standard_EXPORT void GetOrigin (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, Standard_Real& x0, Standard_Real& y0, Standard_Real& z0) const;
//! Finds a voxel corresponding to a 3D point.
//! Returns true if it is found.
Standard_EXPORT Standard_Boolean GetVoxel (const Standard_Real x, const Standard_Real y, const Standard_Real z, Standard_Integer& ix, Standard_Integer& iy, Standard_Integer& iz) const;
//! Returns x-index of a voxel corresponding to x-coordinate.
Standard_EXPORT Standard_Boolean GetVoxelX (const Standard_Real x, Standard_Integer& ix) const;
//! Returns y-index of a voxel corresponding to y-coordinate.
Standard_EXPORT Standard_Boolean GetVoxelY (const Standard_Real y, Standard_Integer& iy) const;
//! Returns z-index of a voxel corresponding to z-coordinate.
Standard_EXPORT Standard_Boolean GetVoxelZ (const Standard_Real z, Standard_Integer& iz) const;
friend class Voxel_Writer;
friend class Voxel_Reader;
protected:
Standard_Address myData;
Standard_Real myX;
Standard_Real myY;
Standard_Real myZ;
Standard_Real myXLen;
Standard_Real myYLen;
Standard_Real myZLen;
Standard_Integer myNbX;
Standard_Integer myNbY;
Standard_Integer myNbZ;
Standard_Integer myNbXY;
Standard_Real myDX;
Standard_Real myDY;
Standard_Real myDZ;
Standard_Real myHalfDX;
Standard_Real myHalfDY;
Standard_Real myHalfDZ;
private:
};
#endif // _Voxel_DS_HeaderFile

1174
src/Voxel/Voxel_FastConverter.cxx
View File

File diff suppressed because it is too large Load Diff

135
src/Voxel/Voxel_FastConverter.hxx
View File

@ -1,135 +0,0 @@
// Created on: 2008-05-30
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_FastConverter_HeaderFile
#define _Voxel_FastConverter_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TopoDS_Shape.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Byte.hxx>
class TopoDS_Shape;
class Voxel_BoolDS;
class Voxel_ColorDS;
class Voxel_ROctBoolDS;
class gp_Pnt;
class gp_Pln;
//! Converts a shape to voxel representation.
//! It does it fast, but with less precision.
//! Also, it doesn't fill-in volumic part of the shape.
class Voxel_FastConverter
{
public:
DEFINE_STANDARD_ALLOC
//! A constructor for conversion of a shape into a cube of boolean voxels.
//! It allocates the voxels in memory.
//! "nbthreads" defines the number of threads used to convert the shape.
Standard_EXPORT Voxel_FastConverter(const TopoDS_Shape& shape, Voxel_BoolDS& voxels, const Standard_Real deflection = 0.1, const Standard_Integer nbx = 10, const Standard_Integer nby = 10, const Standard_Integer nbz = 10, const Standard_Integer nbthreads = 1, const Standard_Boolean useExistingTriangulation = Standard_False);
//! A constructor for conversion of a shape into a cube of colored voxels.
//! It allocates the voxels in memory.
//! "nbthreads" defines the number of threads used to convert the shape.
Standard_EXPORT Voxel_FastConverter(const TopoDS_Shape& shape, Voxel_ColorDS& voxels, const Standard_Real deflection = 0.1, const Standard_Integer nbx = 10, const Standard_Integer nby = 10, const Standard_Integer nbz = 10, const Standard_Integer nbthreads = 1, const Standard_Boolean useExistingTriangulation = Standard_False);
//! A constructor for conversion of a shape into a cube of boolean voxels
//! split into 8 sub-voxels recursively.
//! It allocates the voxels in memory.
//! "nbthreads" defines the number of threads used to convert the shape.
Standard_EXPORT Voxel_FastConverter(const TopoDS_Shape& shape, Voxel_ROctBoolDS& voxels, const Standard_Real deflection = 0.1, const Standard_Integer nbx = 10, const Standard_Integer nby = 10, const Standard_Integer nbz = 10, const Standard_Integer nbthreads = 1, const Standard_Boolean useExistingTriangulation = Standard_False);
//! Converts a shape into a voxel representation.
//! It sets to 0 the outside volume of the shape and
//! 1 for surfacic part of the shape.
//! "ithread" is the index of the thread for current call of ::Convert().
//! Start numeration of "ithread" with 1, please.
Standard_EXPORT Standard_Boolean Convert (Standard_Integer& progress, const Standard_Integer ithread = 1);
//! Converts a shape into a voxel representation using separating axis theorem.
//! It sets to 0 the outside volume of the shape and
//! 1 for surfacic part of the shape.
//! "ithread" is the index of the thread for current call of ::Convert().
//! Start numeration of "ithread" with 1, please.
Standard_EXPORT Standard_Boolean ConvertUsingSAT (Standard_Integer& progress, const Standard_Integer ithread = 1);
//! Fills-in volume of the shape by a value.
Standard_EXPORT Standard_Boolean FillInVolume (const Standard_Byte inner, const Standard_Integer ithread = 1);
//! Fills-in volume of the shape by a value.
//! Uses the topological information from the provided shape
//! to judge whether points are inside the shape or not
//! (only when processing vertical faces).
//! The inner value has to be positive.
Standard_EXPORT Standard_Boolean FillInVolume (const Standard_Byte inner, const TopoDS_Shape& shape, const Standard_Integer ithread = 1);
//! A destructor.
Standard_EXPORT void Destroy();
~Voxel_FastConverter()
{
Destroy();
}
protected:
private:
Standard_EXPORT void Init();
Standard_EXPORT void GetBndBox (const gp_Pnt& p1, const gp_Pnt& p2, const gp_Pnt& p3, Standard_Real& xmin, Standard_Real& ymin, Standard_Real& zmin, Standard_Real& xmax, Standard_Real& ymax, Standard_Real& zmax) const;
Standard_EXPORT void ComputeVoxelsNearTriangle (const gp_Pln& plane, const gp_Pnt& p1, const gp_Pnt& p2, const gp_Pnt& p3, const Standard_Real hdiag, const Standard_Integer ixmin, const Standard_Integer iymin, const Standard_Integer izmin, const Standard_Integer ixmax, const Standard_Integer iymax, const Standard_Integer izmax) const;
Standard_EXPORT void ComputeVoxelsNearTriangle (const gp_Pnt& p1, const gp_Pnt& p2, const gp_Pnt& p3, const gp_Pnt& extents, const gp_Pnt& extents2, const gp_Pnt& extents4, const Standard_Integer ixmin, const Standard_Integer iymin, const Standard_Integer izmin, const Standard_Integer ixmax, const Standard_Integer iymax, const Standard_Integer izmax) const;
TopoDS_Shape myShape;
Standard_Address myVoxels;
Standard_Real myDeflection;
Standard_Integer myIsBool;
Standard_Integer myNbX;
Standard_Integer myNbY;
Standard_Integer myNbZ;
Standard_Integer myNbThreads;
Standard_Integer myNbTriangles;
Standard_Boolean myUseExistingTriangulation;
};
#endif // _Voxel_FastConverter_HeaderFile

116
src/Voxel/Voxel_FloatDS.cxx
View File

@ -1,116 +0,0 @@
// Created on: 2008-05-15
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Voxel_FloatDS.hxx>
#include <stdlib.h>
// Empty constructor
Voxel_FloatDS::Voxel_FloatDS():Voxel_DS()
{
}
// Constructor with intialization.
Voxel_FloatDS::Voxel_FloatDS(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
:Voxel_DS()
{
Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
}
// Initialization.
void Voxel_FloatDS::Init(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
Destroy();
Voxel_DS::Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
if (!myNbX || !myNbY || !myNbZ)
return;
Standard_Integer nb_floats = myNbXY * myNbZ;
Standard_Integer nb_slices = RealToInt(ceil(nb_floats / 32.0)); // 32 values in 1 slice
myData = (Standard_Address) calloc(nb_slices, sizeof(Standard_ShortReal*));
}
// Destructor
void Voxel_FloatDS::Destroy()
{
if (myData)
{
SetZero();
free((Standard_ShortReal**)myData);
myData = 0;
}
}
void Voxel_FloatDS::SetZero()
{
if (myData)
{
Standard_Integer nb_bytes = myNbXY * myNbZ;
Standard_Integer ix = 0, nb_slices = RealToInt(ceil(nb_bytes / 32.0));
for (; ix < nb_slices; ix++)
{
if (((Standard_ShortReal**)myData)[ix])
{
free(((Standard_ShortReal**)myData)[ix]);
((Standard_ShortReal**)myData)[ix] = 0;
}
}
}
}
// Access to the floating-point information attached to a particular voxel:
// Info: (ix >= 0 && ix < theNb_x), etc.
void Voxel_FloatDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_ShortReal data)
{
Standard_Integer ifloat = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ifloat >> 5;
// Allocate the slice if it is not done yet.
if (!((Standard_ShortReal**)myData)[islice])
{
((Standard_ShortReal**)myData)[islice] =
(Standard_ShortReal*) calloc(32/*number of floating values in slice*/, sizeof(Standard_ShortReal));
}
// Index of start-byte of the value within the slice.
Standard_Integer ivalue = ifloat - (islice << 5);
// Value (float)
((Standard_ShortReal*)((Standard_ShortReal**)myData)[islice])[ivalue] = data;
}
Standard_ShortReal Voxel_FloatDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Integer ifloat = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ifloat >> 5;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Standard_ShortReal**)myData)[islice])
return 0.0f;
// Index of start-byte of the value within the slice.
Standard_Integer ivalue = ifloat - (islice << 5);
// Value (floating-point value)
return ((Standard_ShortReal*)((Standard_ShortReal**)myData)[islice])[ivalue];
}

96
src/Voxel/Voxel_FloatDS.hxx
View File

@ -1,96 +0,0 @@
// Created on: 2008-05-15
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_FloatDS_HeaderFile
#define _Voxel_FloatDS_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Voxel_DS.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_ShortReal.hxx>
//! A 3D voxel model keeping a foating-point
//! value for each voxel.
class Voxel_FloatDS : public Voxel_DS
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_FloatDS();
//! A constructor initializing the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT Voxel_FloatDS(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
//! Initialization of the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT virtual void Init (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z) Standard_OVERRIDE;
//! A destructor of the voxel model.
Standard_EXPORT void Destroy();
~Voxel_FloatDS()
{
Destroy();
}
//! The method sets all values equal to 0 (false) and
//! releases the memory.
Standard_EXPORT void SetZero();
//! Defines a value for voxel with co-ordinates (ix, iy, iz).
//! Initial state of the model is so that all voxels have value 0.0f,
//! and this data doesn't occupy memory.
//! Memory for data is allocating during setting non-zero values.
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_ShortReal data);
//! Returns the value of voxel with co-ordinates (ix, iy, iz).
Standard_EXPORT Standard_ShortReal Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
protected:
private:
};
#endif // _Voxel_FloatDS_HeaderFile

303
src/Voxel/Voxel_OctBoolDS.cxx
View File

@ -1,303 +0,0 @@
// Created on: 2008-08-27
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <TColStd_ListIteratorOfListOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <Voxel_OctBoolDS.hxx>
#include <Voxel_TypeDef.hxx>
#include <stdlib.h>
static Standard_Byte gbits[8] = {1, 2, 4, 8, 16, 32, 64, 128};
static Standard_Byte gnbits[8] = {255-1, 255-2, 255-4, 255-8, 255-16, 255-32, 255-64, 255-128};
static iXYZ xyz;
// Empty constructor
Voxel_OctBoolDS::Voxel_OctBoolDS():Voxel_DS(),mySubVoxels(0)
{
}
// Constructor with intialization.
Voxel_OctBoolDS::Voxel_OctBoolDS(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
:Voxel_DS(),mySubVoxels(0)
{
Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
}
// Initialization.
void Voxel_OctBoolDS::Init(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
Destroy();
Voxel_DS::Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
if (!myNbX || !myNbY || !myNbZ)
return;
Standard_Integer nb_bytes = RealToInt(ceil(myNbXY * myNbZ / 8.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 8.0));
myData = (Standard_Address) calloc(nb_slices, sizeof(Standard_Byte*));
}
// Destructor
void Voxel_OctBoolDS::Destroy()
{
if (myData)
{
SetZero();
free((Standard_Byte**)myData);
myData = 0;
if (mySubVoxels)
{
delete (iXYZBool*)mySubVoxels;
mySubVoxels = 0;
}
}
}
void Voxel_OctBoolDS::SetZero()
{
if (myData)
{
Standard_Integer nb_bytes = RealToInt(ceil(myNbXY * myNbZ / 8.0));
Standard_Integer ix = 0, nb_slices = RealToInt(ceil(nb_bytes / 8.0));
for (; ix < nb_slices; ix++)
{
if (((Standard_Byte**)myData)[ix])
{
free(((Standard_Byte**)myData)[ix]);
((Standard_Byte**)myData)[ix] = 0;
}
}
}
if (mySubVoxels)
{
iXYZBool* map = (iXYZBool*) mySubVoxels;
map->Clear();
}
}
// Access to the boolean information attached to a particular voxel:
// Info: (ix >= 0 && ix < theNb_x), etc.
void Voxel_OctBoolDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Boolean data)
{
// All 8 sub-voxels have the same value.
// No need anymore to keep them in memory.
if (IsSplit(ix, iy, iz))
{
UnSplit(ix, iy, iz);
}
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 6;
if (!data && !((Standard_Byte**)myData)[islice])
return; // don't allocate a slice of data for setting a 0 value
// Allocate the slice if it is not done yet.
if (!((Standard_Byte**)myData)[islice])
{
((Standard_Byte**)myData)[islice] = (Standard_Byte*) calloc(8/*number of bytes in slice*/, sizeof(Standard_Byte));
}
// Index within 8 bytes of the slice.
Standard_Integer ibit_in_current_slice = ibit - (islice << 6);
Standard_Integer ibyte = ibit_in_current_slice >> 3;
// Value (byte)
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte];
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit_in_current_slice - (ibyte << 3);
// Set data
if (data != ((value & gbits[shift]) ? Standard_True : Standard_False))
{
if (data)
value |= gbits[shift];
else
value &= gnbits[shift];
((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte] = value;
}
}
void Voxel_OctBoolDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer ioct, const Standard_Boolean data)
{
// If the voxel is not split yet, do it now.
if (!IsSplit(ix, iy, iz))
{
Split(ix, iy, iz);
}
// Voxel
xyz.ix = ix;
xyz.iy = iy;
xyz.iz = iz;
// Take the value
Standard_Byte value = ((iXYZBool*)mySubVoxels)->Find(xyz);
// Set data
if (data != ((value & gbits[ioct]) ? Standard_True : Standard_False))
{
if (data)
value |= gbits[ioct];
else
value &= gnbits[ioct];
((iXYZBool*)mySubVoxels)->ChangeFind(xyz) = value;
}
}
Standard_Boolean Voxel_OctBoolDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 6;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Standard_Byte**)myData)[islice])
return Standard_False;
// Index within 8 bytes of the slice.
Standard_Integer ibit_in_current_slice = ibit - (islice << 6);
Standard_Integer ibyte = ibit_in_current_slice >> 3;
// Value (byte)
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)myData)[islice])[ibyte];
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit_in_current_slice - (ibyte << 3);
return ((value & gbits[shift]) ? Standard_True : Standard_False);
}
Standard_Boolean Voxel_OctBoolDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer ioct) const
{
// If the voxel is not split, return the value of the voxel.
if (!IsSplit(ix, iy, iz))
{
return Get(ix, iy, iz);
}
// Voxel
xyz.ix = ix;
xyz.iy = iy;
xyz.iz = iz;
// Take the value
const Standard_Byte value = ((iXYZBool*)mySubVoxels)->Find(xyz);
// Return data
return (value & gbits[ioct]) ? Standard_True : Standard_False;
}
Standard_Boolean Voxel_OctBoolDS::IsSplit(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
if (!mySubVoxels)
return Standard_False;
// Voxel
xyz.ix = ix;
xyz.iy = iy;
xyz.iz = iz;
return ((iXYZBool*)mySubVoxels)->IsBound(xyz);
}
void Voxel_OctBoolDS::Split(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz)
{
// Voxel
xyz.ix = ix;
xyz.iy = iy;
xyz.iz = iz;
if (mySubVoxels)
{
if (!((iXYZBool*)mySubVoxels)->IsBound(xyz))
{
((iXYZBool*)mySubVoxels)->Bind(xyz, 0);
}
}
else
{
mySubVoxels = (Standard_Address) new iXYZBool;
((iXYZBool*)mySubVoxels)->Bind(xyz, 0);
}
}
void Voxel_OctBoolDS::UnSplit(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz)
{
if (!mySubVoxels)
return;
// Voxel
xyz.ix = ix;
xyz.iy = iy;
xyz.iz = iz;
if (((iXYZBool*)mySubVoxels)->IsBound(xyz))
{
((iXYZBool*)mySubVoxels)->UnBind(xyz);
}
}
void Voxel_OctBoolDS::OptimizeMemory()
{
if (!mySubVoxels)
return;
Standard_Byte value;
TColStd_ListOfInteger ixs, iys, izs, values;
iXYZBool::Iterator itr(*((iXYZBool*)mySubVoxels));
for (; itr.More(); itr.Next())
{
value = itr.Value();
if (value == 0 || value == 255)
{
xyz = itr.Key();
ixs.Append(xyz.ix);
iys.Append(xyz.iy);
izs.Append(xyz.iz);
values.Append((Standard_Integer)value);
}
}
TColStd_ListIteratorOfListOfInteger itrix(ixs), itriy(iys), itriz(izs), itrvalues(values);
for (; itrix.More(); itrix.Next(), itriy.Next(), itriz.Next(), itrvalues.Next())
{
const Standard_Integer ix = itrix.Value();
const Standard_Integer iy = itriy.Value();
const Standard_Integer iz = itriz.Value();
const Standard_Integer aValue = itrvalues.Value();
Set(ix, iy, iz, (aValue ? Standard_True : Standard_False));
UnSplit(ix, iy, iz);
}
// If the map is empty, release it.
if (((iXYZBool*)mySubVoxels)->IsEmpty())
{
delete (iXYZBool*)mySubVoxels;
mySubVoxels = 0;
}
}

123
src/Voxel/Voxel_OctBoolDS.hxx
View File

@ -1,123 +0,0 @@
// Created on: 2008-08-26
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_OctBoolDS_HeaderFile
#define _Voxel_OctBoolDS_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Voxel_DS.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! A 3D voxel model keeping a boolean flag (1 or 0)
//! value for each voxel, and having an opportunity to split each voxel
//! into 8 sub-voxels.
class Voxel_OctBoolDS : public Voxel_DS
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_OctBoolDS();
//! A constructor initializing the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT Voxel_OctBoolDS(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
//! Initialization of the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT virtual void Init (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z) Standard_OVERRIDE;
//! A destructor of the voxel model.
Standard_EXPORT void Destroy();
~Voxel_OctBoolDS()
{
Destroy();
}
//! The method sets all values equal to 0 (false) and
//! releases the memory.
Standard_EXPORT void SetZero();
//! The method searches voxels with equal-value of sub-voxels
//! and removes them (remaining the value for the voxel).
Standard_EXPORT void OptimizeMemory();
//! Defines a value for voxel with co-ordinates (ix, iy, iz).
//! If the voxel is split into 8 sub-voxels, the split disappears.
//! Initial state of the model is so that all voxels have value 0 (false),
//! and this data doesn't occupy memory.
//! Memory for data is allocating during setting non-zero values (true).
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Boolean data);
//! Defines a value for a sub-voxel of a voxel with co-ordinates (ix, iy, iz).
//! If the voxel is not split into 8 sub-voxels yet, this method splits the voxel.
//! Range of sub-voxels is 0 - 7.
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer ioct, const Standard_Boolean data);
//! Returns the value of voxel with co-ordinates (ix, iy, iz).
//! Warning!: the returned value may not coincide with the value of its 8 sub-voxels.
//! Use the method ::IsSplit() to check whether a voxel has sub-voxels.
Standard_EXPORT Standard_Boolean Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
//! Returns the value of a sub-voxel of a voxel with co-ordinates (ix, iy, iz).
//! If the voxel is not split, it returns the value of the voxel.
//! Range of sub-voxels is 0 - 7.
Standard_EXPORT Standard_Boolean Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer ioct) const;
//! Returns true if the voxel is split into 8 sub-voxels.
Standard_EXPORT Standard_Boolean IsSplit (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
protected:
private:
Standard_EXPORT void Split (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz);
Standard_EXPORT void UnSplit (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz);
Standard_Address mySubVoxels;
};
#endif // _Voxel_OctBoolDS_HeaderFile

307
src/Voxel/Voxel_Prs.cxx
View File

@ -1,307 +0,0 @@
// Created on: 2008-05-13
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_Group.hxx>
#include <Graphic3d_MaterialAspect.hxx>
#include <Poly_Triangulation.hxx>
#include <Prs3d_Presentation.hxx>
#include <Prs3d_Root.hxx>
#include <Quantity_Color.hxx>
#include <Standard_Type.hxx>
#include <Voxel_Prs.hxx>
#include "Voxel_VisData.h"
Voxel_Prs::Voxel_Prs():AIS_InteractiveObject(PrsMgr_TOP_AllView),myVisData(0)
{
}
void Voxel_Prs::SetBoolVoxels(const Standard_Address theVoxels)
{
Allocate();
((Voxel_VisData*)myVisData)->myBoolVoxels = (Voxel_BoolDS*) theVoxels;
}
void Voxel_Prs::SetColorVoxels(const Standard_Address theVoxels)
{
Allocate();
((Voxel_VisData*)myVisData)->myColorVoxels = (Voxel_ColorDS*) theVoxels;
}
void Voxel_Prs::SetROctBoolVoxels(const Standard_Address theVoxels)
{
Allocate();
((Voxel_VisData*)myVisData)->myROctBoolVoxels = (Voxel_ROctBoolDS*) theVoxels;
}
void Voxel_Prs::SetTriangulation(const Handle(Poly_Triangulation)& theTriangulation)
{
Allocate();
((Voxel_VisData*)myVisData)->myTriangulation = theTriangulation;
}
void Voxel_Prs::SetColor(const Quantity_Color& theColor)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myColor = theColor;
}
void Voxel_Prs::SetPointSize(const Standard_Real theSize)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myPointSize = theSize;
}
void Voxel_Prs::SetQuadrangleSize(const Standard_Integer theSize)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myQuadrangleSize = theSize;
}
void Voxel_Prs::SetColors(const Handle(Quantity_HArray1OfColor)& theColors)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myColors = theColors;
}
void Voxel_Prs::SetDisplayMode(const Voxel_VoxelDisplayMode theMode)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myDisplayMode = theMode;
}
void Voxel_Prs::SetTransparency(const Standard_Real theTransparency)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myTransparency = theTransparency;
}
static void setMaterial(const Handle(Graphic3d_Group)& G,
const Quantity_Color& C,
const Standard_Real T)
{
Graphic3d_MaterialAspect material(Graphic3d_NOM_PLASTIC);
material.SetColor(C);
material.SetTransparency(T);
Handle(Graphic3d_AspectFillArea3d) aspect =
new Graphic3d_AspectFillArea3d(Aspect_IS_SOLID, C, C, Aspect_TOL_SOLID, 1, material, material);
aspect->SetDistinguishOff();
aspect->SetEdgeOff();
aspect->SetTextureMapOff();
G->SetPrimitivesAspect(aspect);
}
void Voxel_Prs::Compute(const Handle(PrsMgr_PresentationManager3d)& /*thePresentationManager*/,
const Handle(Prs3d_Presentation)& thePresentation,
const Standard_Integer /*theMode*/)
{
thePresentation->Clear();
if (!myVisData)
return;
if (((Voxel_VisData*)myVisData)->myBoolVoxels)
{
// Reset GL lists.
// BoolDS
((Voxel_VisData*)myVisData)->myDisplay.myBoolPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsFirst = 1;
}
if (((Voxel_VisData*)myVisData)->myColorVoxels)
{
// Reset GL lists.
// ColorDS
((Voxel_VisData*)myVisData)->myDisplay.myColorPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsFirst = 1;
}
if (((Voxel_VisData*)myVisData)->myROctBoolVoxels)
{
// Reset GL lists.
// ROctBoolDS
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsFirst = 1;
}
// Set data to the user draw function.
Handle(Graphic3d_Group) G = Prs3d_Root::CurrentGroup(thePresentation);
if (((Voxel_VisData*)myVisData)->myDisplay.myDisplayMode == Voxel_VDM_BOXES ||
((Voxel_VisData*)myVisData)->myDisplay.myDisplayMode == Voxel_VDM_NEARESTBOXES ||
!((Voxel_VisData*)myVisData)->myTriangulation.IsNull())
{
setMaterial(G, ((Voxel_VisData*)myVisData)->myDisplay.myColor,
((Voxel_VisData*)myVisData)->myDisplay.myTransparency);
// Reset normals of triangulation
if (!((Voxel_VisData*)myVisData)->myTriangulation.IsNull())
{
((Voxel_VisData*)myVisData)->myNormalsOfNodes.Nullify();
((Voxel_VisData*)myVisData)->myDisplay.myTriangulationList = -1;
}
}
///Handle(OpenGl_Group) aGroup = Handle(OpenGl_Group)::DownCast (G);
///aGroup->AddElement (myVisData);
}
void Voxel_Prs::ComputeSelection(const Handle(SelectMgr_Selection)& /*theSelection*/,
const Standard_Integer /*theMode*/)
{
}
// Destructor
void Voxel_Prs::Destroy()
{
if (myVisData)
{
delete (Voxel_VisData*) myVisData;
myVisData = 0;
}
}
void Voxel_Prs::Allocate()
{
if (!myVisData)
{
myVisData = new Voxel_VisData;
((Voxel_VisData*)myVisData)->myBoolVoxels = 0;
((Voxel_VisData*)myVisData)->myColorVoxels = 0;
((Voxel_VisData*)myVisData)->myROctBoolVoxels = 0;
// Points
// BoolDS
((Voxel_VisData*)myVisData)->myDisplay.myBoolPointsList = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[0] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[1] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[2] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[3] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[4] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[5] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsList[6] = -1;
// ROctBoolDS
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolPointsList = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[0] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[1] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[2] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[3] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[4] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[5] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsList[6] = -1;
// ColorDS:
((Voxel_VisData*)myVisData)->myDisplay.myColorPointsList = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[0] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[1] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[2] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[3] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[4] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[5] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsList[6] = -1;
((Voxel_VisData*)myVisData)->myDisplay.myColorMinValue = 1;
((Voxel_VisData*)myVisData)->myDisplay.myColorMaxValue = 15;
((Voxel_VisData*)myVisData)->myDisplay.myPointSize = 1.0;
((Voxel_VisData*)myVisData)->myDisplay.myQuadrangleSize = 100;
((Voxel_VisData*)myVisData)->myDisplay.myTransparency = 0.0;
((Voxel_VisData*)myVisData)->myDisplay.myDegenerateMode = 0;
((Voxel_VisData*)myVisData)->myDisplay.myUsageOfGLlists = 1;
((Voxel_VisData*)myVisData)->myDisplay.mySmoothPoints = 0;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedXMin = -DBL_MAX;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedXMax = DBL_MAX;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedYMin = -DBL_MAX;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedYMax = DBL_MAX;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedZMin = -DBL_MAX;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedZMax = DBL_MAX;
((Voxel_VisData*)myVisData)->myDisplay.myTriangulationList = -1;
((Voxel_VisData*)myVisData)->myDisplay.myHighlightx = -1;
((Voxel_VisData*)myVisData)->myDisplay.myHighlighty = -1;
((Voxel_VisData*)myVisData)->myDisplay.myHighlightz = -1;
}
}
void Voxel_Prs::SetDegenerateMode(const Standard_Boolean theDegenerate)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myDegenerateMode = (theDegenerate == Standard_True);
}
void Voxel_Prs::SetUsageOfGLlists(const Standard_Boolean theUsage)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myUsageOfGLlists = (theUsage == Standard_True);
}
void Voxel_Prs::SetSmoothPoints(const Standard_Boolean theSmooth)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.mySmoothPoints = (theSmooth == Standard_True);
}
void Voxel_Prs::SetColorRange(const Standard_Byte theMinValue,
const Standard_Byte theMaxValue)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myColorMinValue = theMinValue;
((Voxel_VisData*)myVisData)->myDisplay.myColorMaxValue = theMaxValue;
// Reset GL lists
((Voxel_VisData*)myVisData)->myDisplay.myColorPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsFirst = 1;
}
void Voxel_Prs::SetSizeRange(const Standard_Real theDisplayedXMin,
const Standard_Real theDisplayedXMax,
const Standard_Real theDisplayedYMin,
const Standard_Real theDisplayedYMax,
const Standard_Real theDisplayedZMin,
const Standard_Real theDisplayedZMax)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedXMin = theDisplayedXMin;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedXMax = theDisplayedXMax;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedYMin = theDisplayedYMin;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedYMax = theDisplayedYMax;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedZMin = theDisplayedZMin;
((Voxel_VisData*)myVisData)->myDisplay.myDisplayedZMax = theDisplayedZMax;
// Reset GL lists
((Voxel_VisData*)myVisData)->myDisplay.myBoolPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myBoolNearestPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myColorPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myColorNearestPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolPointsFirst = 1;
((Voxel_VisData*)myVisData)->myDisplay.myROctBoolNearestPointsFirst = 1;
}
void Voxel_Prs::Highlight(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz)
{
Allocate();
((Voxel_VisData*)myVisData)->myDisplay.myHighlightx = ix;
((Voxel_VisData*)myVisData)->myDisplay.myHighlighty = iy;
((Voxel_VisData*)myVisData)->myDisplay.myHighlightz = iz;
}

149
src/Voxel/Voxel_Prs.hxx
View File

@ -1,149 +0,0 @@
// Created on: 2008-05-06
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_Prs_HeaderFile
#define _Voxel_Prs_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Address.hxx>
#include <AIS_InteractiveObject.hxx>
#include <Voxel_VoxelDisplayMode.hxx>
#include <Quantity_HArray1OfColor.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <PrsMgr_PresentationManager3d.hxx>
#include <SelectMgr_Selection.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Byte.hxx>
class Poly_Triangulation;
class Quantity_Color;
class Prs3d_Presentation;
class Voxel_Prs;
DEFINE_STANDARD_HANDLE(Voxel_Prs, AIS_InteractiveObject)
//! Interactive object for voxels.
class Voxel_Prs : public AIS_InteractiveObject
{
public:
//! An empty constructor.
Standard_EXPORT Voxel_Prs();
//! <theVoxels> is a Voxel_BoolDS* object.
Standard_EXPORT void SetBoolVoxels (const Standard_Address theVoxels);
//! <theVoxels> is a Voxel_ColorDS* object.
Standard_EXPORT void SetColorVoxels (const Standard_Address theVoxels);
//! <theVoxels> is a Voxel_ROctBoolDS* object.
Standard_EXPORT void SetROctBoolVoxels (const Standard_Address theVoxels);
//! Sets a triangulation for visualization.
Standard_EXPORT void SetTriangulation (const Handle(Poly_Triangulation)& theTriangulation);
//! Sets a display mode for voxels.
Standard_EXPORT void SetDisplayMode (const Voxel_VoxelDisplayMode theMode);
//! Defines the color of points, quadrangles ... for BoolDS.
Standard_EXPORT virtual void SetColor (const Quantity_Color& theColor) Standard_OVERRIDE;
//! Defines the color of points, quadrangles... for ColorDS.
//! For ColorDS the size of array is 0 .. 15.
//! 0 - means no color, this voxel is not drawn.
Standard_EXPORT void SetColors (const Handle(Quantity_HArray1OfColor)& theColors);
//! Defines the size of points for all types of voxels.
Standard_EXPORT void SetPointSize (const Standard_Real theSize);
//! Defines the size of quadrangles in per cents (0 .. 100).
Standard_EXPORT void SetQuadrangleSize (const Standard_Integer theSize);
//! Defines the transparency value [0 .. 1] for quadrangular visualization.
Standard_EXPORT virtual void SetTransparency (const Standard_Real theTransparency) Standard_OVERRIDE;
//! Highlights a voxel.
//! It doesn't re-computes the whole interactive object,
//! but only marks a voxels as "highlighted".
//! The voxel becomes highlighted on next swapping of buffers.
//! In order to unhighlight a voxel, set ix = iy = iz = -1.
Standard_EXPORT void Highlight (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz);
//! A destructor of presentation data.
Standard_EXPORT void Destroy();
~Voxel_Prs()
{
Destroy();
}
//! Simplifies visualization of voxels in case of view rotation, panning and zooming.
Standard_EXPORT void SetDegenerateMode (const Standard_Boolean theDegenerate);
//! GL lists accelerate view rotation, panning and zooming operations, but
//! it takes additional memory...
//! It is up to the user of this interactive object to decide whether
//! he has enough memory and may use GL lists or
//! he is lack of memory and usage of GL lists is not recommended.
//! By default, usage of GL lists is on.
//! Also, as I noticed, the view without GL lists looks more precisely.
Standard_EXPORT void SetUsageOfGLlists (const Standard_Boolean theUsage);
//! Switches visualization of points from smooth to rough.
Standard_EXPORT void SetSmoothPoints (const Standard_Boolean theSmooth);
//! Defines min-max values for visualization of voxels of ColorDS structure.
//! By default, min value = 1, max value = 15 (all non-zero values).
Standard_EXPORT void SetColorRange (const Standard_Byte theMinValue, const Standard_Byte theMaxValue);
//! Defines the displayed area of voxels.
//! By default, the range is equal to the box of voxels (all voxels are displayed).
Standard_EXPORT void SetSizeRange (const Standard_Real theDisplayedXMin, const Standard_Real theDisplayedXMax, const Standard_Real theDisplayedYMin, const Standard_Real theDisplayedYMax, const Standard_Real theDisplayedZMin, const Standard_Real theDisplayedZMax);
DEFINE_STANDARD_RTTI(Voxel_Prs,AIS_InteractiveObject)
protected:
Standard_EXPORT virtual void Compute (const Handle(PrsMgr_PresentationManager3d)& thePresentationManager, const Handle(Prs3d_Presentation)& thePresentation, const Standard_Integer theMode = 0) Standard_OVERRIDE;
protected:
Standard_EXPORT void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection, const Standard_Integer theMode);
//! Allocates the data structure of visualization.
Standard_EXPORT void Allocate();
Standard_Address myVisData;
};
#endif // _Voxel_Prs_HeaderFile

727
src/Voxel/Voxel_ROctBoolDS.cxx
View File

@ -1,727 +0,0 @@
// Created on: 2008-09-01
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Voxel_ROctBoolDS.hxx>
#include <Voxel_SplitData.hxx>
#include <stdlib.h>
static Standard_Byte gbits[8] = {1, 2, 4, 8, 16, 32, 64, 128};
static Standard_Byte gnbits[8] = {255-1, 255-2, 255-4, 255-8, 255-16, 255-32, 255-64, 255-128};
/* Data structure of the ROctBoolDS
SplitData: 1 byte (8 values)
(a) SplitData: 8 bytes (64 values)
(b) SplitData: 64 bytes (512 values)
(c) SplitData: ...
(d) SplitData: ...
*/
// Empty constructor
Voxel_ROctBoolDS::Voxel_ROctBoolDS():Voxel_DS()
{
}
// Constructor with intialization.
Voxel_ROctBoolDS::Voxel_ROctBoolDS(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
:Voxel_DS()
{
Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
}
// Initialization.
void Voxel_ROctBoolDS::Init(const Standard_Real x, const Standard_Real y, const Standard_Real z,
const Standard_Real xlen, const Standard_Real ylen, const Standard_Real zlen,
const Standard_Integer nbx, const Standard_Integer nby, const Standard_Integer nbz)
{
Destroy();
Voxel_DS::Init(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
if (!myNbX || !myNbY || !myNbZ)
return;
Standard_Integer nb_slices = RealToInt(ceil(myNbXY * myNbZ / 8.0));
myData = (Standard_Address) calloc(nb_slices, sizeof(Voxel_SplitData*));
}
// Destructor
void Voxel_ROctBoolDS::Destroy()
{
if (myData)
{
SetZero();
free((Voxel_SplitData**)myData);
myData = 0;
}
}
// A recursive method of deletion of data.
static void SetZeroSplitData(Voxel_SplitData* data)
{
// Values:
free((Standard_Byte*) data->GetValues());
data->GetValues() = 0;
if (data->GetSplitData())
{
SetZeroSplitData((Voxel_SplitData*) data->GetSplitData());
}
delete data;
}
void Voxel_ROctBoolDS::SetZero()
{
if (myData)
{
Standard_Integer ix = 0, nb_slices = RealToInt(ceil(myNbXY * myNbZ / 8.0));
for (; ix < nb_slices; ix++)
{
if (((Voxel_SplitData**)myData)[ix])
{
SetZeroSplitData((Voxel_SplitData*)((Voxel_SplitData**)myData)[ix]);
((Voxel_SplitData**)myData)[ix] = 0;
}
}
}
}
// Access to the boolean information attached to a particular voxel:
// Info: (ix >= 0 && ix < theNb_x), etc.
void Voxel_ROctBoolDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Boolean data)
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
if (!data && !((Voxel_SplitData**)myData)[islice])
return; // don't allocate a slice of data for setting a 0 value
// Allocate the slice if it is not done yet.
if (!((Voxel_SplitData**)myData)[islice])
{
((Voxel_SplitData**)myData)[islice] = (Voxel_SplitData*) new Voxel_SplitData;
// Values:
((Voxel_SplitData**)myData)[islice]->GetValues() =
(Standard_Byte*) calloc(1/*one byte: 8 1-bit values*/, sizeof(Standard_Byte));
// Sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData() = 0;
}
// Value
Standard_Byte value = *((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues());
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit - (islice << 3);
// Set data
if (data != ((value & gbits[shift]) ? Standard_True : Standard_False))
{
if (data)
value |= gbits[shift];
else
value &= gnbits[shift];
*((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues()) = value;
}
// Set the same value to sub-voxels.
if (((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
{
// Get sub-value
Standard_Byte subvalue = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[shift];
// Set sub-value
if (subvalue != (data ? 255 : 0))
{
subvalue = data ? 255 : 0;
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[shift] = subvalue;
}
// Set the same value to sub-sub-voxels.
if (((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())
{
// Start index of 64-bit value (index of byte of sub-sub-voxel).
Standard_Integer ibyte2 = (shift << 3);
for (Standard_Integer ioct2 = 0; ioct2 < 8; ioct2++)
{
// Get sub-sub-value
Standard_Byte subsubvalue = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2 + ioct2];
// Set sub-sub-value
if (subsubvalue != (data ? 255 : 0))
{
subsubvalue = data ? 255 : 0;
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2 + ioct2] = subsubvalue;
}
}
}
}
}
void Voxel_ROctBoolDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer ioct1, const Standard_Boolean data)
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
if (!data && !((Voxel_SplitData**)myData)[islice])
return; // don't allocate a slice of data for setting a 0 value
// Allocate the slice if it is not done yet.
if (!((Voxel_SplitData**)myData)[islice])
{
((Voxel_SplitData**)myData)[islice] = (Voxel_SplitData*) new Voxel_SplitData;
// Values:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues() =
(Standard_Byte*) calloc(1/*one byte: 8 1-bit values*/, sizeof(Standard_Byte));
// Sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData() = 0;
}
// Check sub-voxels of the first level
if (!((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
{
// Sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData() = (Voxel_SplitData*) new Voxel_SplitData;
// Value of sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues() =
(Standard_Byte*) calloc(8/*eight bytes: 8 sub-voxels for each voxel*/, sizeof(Standard_Byte));
// Set parent value
Standard_Byte parent_value = *((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues());
if (parent_value)
{
for (Standard_Integer shift = 0; shift < 8; shift++)
{
if ((parent_value & gbits[shift]) ? Standard_True : Standard_False)
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[shift] = 255;
}
else
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[shift] = 0;
}
}
}
// Sub-sub-voxels
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData() = 0;
}
// Index of sub-voxel corresponding to ioct1: 8 voxels correspond to 64 sub-voxels.
Standard_Integer ibyte = ibit - (islice << 3);
// Value
Standard_Byte value = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[ibyte];
// Set data
if (data != ((value & gbits[ioct1]) ? Standard_True : Standard_False))
{
if (data)
value |= gbits[ioct1];
else
value &= gnbits[ioct1];
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[ibyte] = value;
}
// Set the same value to sub-voxels.
if (((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())
{
// Start index of 64-bit value (index of byte of sub-sub-voxel).
Standard_Integer ibyte2 = (ibyte << 3) + ioct1;
// Get sub-sub-value
Standard_Byte subsubvalue = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2];
// Set sub-sub-value
if (subsubvalue != (data ? 255 : 0))
{
subsubvalue = data ? 255 : 0;
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2] = subsubvalue;
}
}
}
void Voxel_ROctBoolDS::Set(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer ioct1, const Standard_Integer ioct2, const Standard_Boolean data)
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
if (!data && !((Voxel_SplitData**)myData)[islice])
return; // don't allocate a slice of data for setting a 0 value
// Allocate the slice if it is not done yet.
if (!((Voxel_SplitData**)myData)[islice])
{
((Voxel_SplitData**)myData)[islice] = (Voxel_SplitData*) new Voxel_SplitData;
// Values:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues() =
(Standard_Byte*) calloc(1/*one byte: 8 1-bit values*/, sizeof(Standard_Byte));
// Sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData() = 0;
}
// Check sub-voxels of the first level
if (!((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
{
// Sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData() = (Voxel_SplitData*) new Voxel_SplitData;
// Value of sub-voxels:
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues() =
(Standard_Byte*) calloc(8/*eight bytes: 8 sub-voxels for each voxel*/, sizeof(Standard_Byte));
// Set parent value
Standard_Byte parent_value = *((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues());
if (parent_value)
{
for (Standard_Integer shift = 0; shift < 8; shift++)
{
if ((parent_value & gbits[shift]) ? Standard_True : Standard_False)
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[shift] = 255;
}
else
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[shift] = 0;
}
}
}
// Sub-sub-voxels
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData() = 0;
}
// Check sub-voxels of the second level
if (!((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())
{
// Sub-voxels 2:
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData() =
(Voxel_SplitData*) new Voxel_SplitData;
// Value of sub-voxels 2:
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues() =
(Standard_Byte*) calloc(64/*sixty four bytes: 8 sub-voxels for each sub-voxel for each voxel*/,
sizeof(Standard_Byte));
// Set parent value
for (Standard_Integer ibyte1 = 0; ibyte1 < 8; ibyte1++)
{
Standard_Byte parent_value = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[ibyte1];
if (parent_value)
{
Standard_Integer ibyte2 = (ibyte1 << 3);
for (Standard_Integer shift = 0; shift < 8; shift++)
{
if ((parent_value & gbits[shift]) ? Standard_True : Standard_False)
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2 + shift] = 255;
}
else
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2 + shift] = 0;
}
}
}
}
// Sub-sub-sub-voxels
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetSplitData() = 0;
}
// Index of sub-voxel corresponding to ioct1: 8 voxels correspond to 64 sub-voxels.
Standard_Integer ibyte1 = ibit - (islice << 3); // imdex of byte of 8-byte value (sub-voxel 1).
Standard_Integer ibyte2 = (ibyte1 << 3) + ioct1; // index of byte of 64-byte value (sub-voxel 2)
// Value
Standard_Byte value = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2];
// Set data
if (data != ((value & gbits[ioct2]) ? Standard_True : Standard_False))
{
if (data)
value |= gbits[ioct2];
else
value &= gnbits[ioct2];
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2] = value;
}
}
Standard_Boolean Voxel_ROctBoolDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Voxel_SplitData**)myData)[islice])
return Standard_False;
// Value (byte)
Standard_Byte value = *((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues());
// Position of data in the 8 bit-"value".
Standard_Integer shift = ibit - (islice << 3);
return ((value & gbits[shift]) ? Standard_True : Standard_False);
}
Standard_Boolean Voxel_ROctBoolDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer ioct1) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Voxel_SplitData**)myData)[islice])
return Standard_False;
// If the voxel is not split, return the value of the voxel.
if (!((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
return Get(ix, iy, iz);
// Index of sub-voxel corresponding to ioct1: 8 voxels correspond to 64 sub-voxels.
Standard_Integer ibyte = ibit - (islice << 3);
// Value
Standard_Byte value = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[ibyte];
return ((value & gbits[ioct1]) ? Standard_True : Standard_False);
}
Standard_Boolean Voxel_ROctBoolDS::Get(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer ioct1, const Standard_Integer ioct2) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
// If the slice of data is not allocated, it means that its values are 0.
if (!((Voxel_SplitData**)myData)[islice])
return Standard_False;
// If the voxel is not split, return the value of the voxel.
if (!((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
return Get(ix, iy, iz);
// If the split voxel (sub-voxel 1) is not split, return the value of the sub-voxel 1.
if (!((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())
return Get(ix, iy, iz, ioct1);
// Index of sub-voxel corresponding to ioct1: 8 voxels correspond to 64 sub-voxels.
Standard_Integer ibyte1 = ibit - (islice << 3); // index of byte of 8-byte value (sub-voxel 1).
Standard_Integer ibyte2 = (ibyte1 << 3) + ioct1; // index of byte of 64-byte value (sub-voxel 2)
// Value
Standard_Byte value = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2];
return ((value & gbits[ioct2]) ? Standard_True : Standard_False);
}
Standard_Boolean Voxel_ROctBoolDS::IsSplit(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
// If the voxel has no value, it is not split.
if (!((Voxel_SplitData**)myData)[islice])
return Standard_False;
// Check existence of sub-voxels
if (((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
return Standard_True;
return Standard_False;
}
Standard_Integer Voxel_ROctBoolDS::Deepness(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const
{
Standard_Integer ibit = ix + myNbX * iy + myNbXY * iz;
Standard_Integer islice = ibit >> 3;
// If the voxel has no value, it is not split.
if (!((Voxel_SplitData**)myData)[islice])
return 0;
// Test deepness.
if (((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
{
if (((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())
{
return 2;
}
else
{
return 1;
}
}
return 0;
}
void Voxel_ROctBoolDS::OptimizeMemory()
{
// Iterate the array of voxels checking coincidence of values of sub-voxels.
Standard_Integer islice = 0, nb_slices = RealToInt(ceil(myNbXY * myNbZ / 8.0));
for (; islice < nb_slices; islice++)
{
if (!((Voxel_SplitData**)myData)[islice])
continue;
if (((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())
{
Standard_Boolean suppress = Standard_False;
// Second level of sub-voxels
if (((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())
{
suppress = Standard_False;
Standard_Byte value1 = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[0];
if (value1 == 0 || value1 == 255)
{
suppress = Standard_True;
for (Standard_Integer ibyte2 = 1; ibyte2 < 64; ibyte2++)
{
Standard_Byte value2 = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData())->GetValues())[ibyte2];
if (value2 != value1)
{
suppress = Standard_False;
break;
}
}
}
if (suppress)
{
SetZeroSplitData((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData());
((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetSplitData() = 0;
// Set value to upper level
for (Standard_Integer ibyte1 = 0; ibyte1 < 8; ibyte1++)
{
((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[ibyte1] = value1;
}
}
else
{
// If we don't suppress sub-sub-voxels, we don't touch sub-voxels.
continue;
}
}
// First level of sub-voxels
suppress = Standard_False;
Standard_Byte value1 = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[0];
if (value1 == 0 || value1 == 255)
{
suppress = Standard_True;
for (Standard_Integer ibyte1 = 1; ibyte1 < 8; ibyte1++)
{
Standard_Byte value2 = ((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData())->GetValues())[ibyte1];
if (value2 != value1)
{
suppress = Standard_False;
break;
}
}
}
if (suppress)
{
SetZeroSplitData((Voxel_SplitData*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData());
((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetSplitData() = 0;
// Set value to upper level
*((Standard_Byte*)((Voxel_SplitData*)((Voxel_SplitData**)myData)[islice])->GetValues()) = value1;
}
}
}
}
void Voxel_ROctBoolDS::GetCenter(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer i,
Standard_Real& xc, Standard_Real& yc, Standard_Real& zc) const
{
xc = myX + ix * myDX;
yc = myY + iy * myDY;
zc = myZ + iz * myDZ;
switch (i)
{
case 0:
{
xc += 0.5 * myHalfDX;
yc += 0.5 * myHalfDY;
zc += 0.5 * myHalfDZ;
break;
}
case 1:
{
xc += 1.5 * myHalfDX;
yc += 0.5 * myHalfDY;
zc += 0.5 * myHalfDZ;
break;
}
case 2:
{
xc += 0.5 * myHalfDX;
yc += 1.5 * myHalfDY;
zc += 0.5 * myHalfDZ;
break;
}
case 3:
{
xc += 1.5 * myHalfDX;
yc += 1.5 * myHalfDY;
zc += 0.5 * myHalfDZ;
break;
}
case 4:
{
xc += 0.5 * myHalfDX;
yc += 0.5 * myHalfDY;
zc += 1.5 * myHalfDZ;
break;
}
case 5:
{
xc += 1.5 * myHalfDX;
yc += 0.5 * myHalfDY;
zc += 1.5 * myHalfDZ;
break;
}
case 6:
{
xc += 0.5 * myHalfDX;
yc += 1.5 * myHalfDY;
zc += 1.5 * myHalfDZ;
break;
}
case 7:
{
xc += 1.5 * myHalfDX;
yc += 1.5 * myHalfDY;
zc += 1.5 * myHalfDZ;
break;
}
}
}
void Voxel_ROctBoolDS::GetCenter(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer i, const Standard_Integer j,
Standard_Real& xc, Standard_Real& yc, Standard_Real& zc) const
{
xc = myX + ix * myDX;
yc = myY + iy * myDY;
zc = myZ + iz * myDZ;
switch (i)
{
case 0:
{
break;
}
case 1:
{
xc += myHalfDX;
break;
}
case 2:
{
yc += myHalfDY;
break;
}
case 3:
{
xc += myHalfDX;
yc += myHalfDY;
break;
}
case 4:
{
zc += myHalfDZ;
break;
}
case 5:
{
xc += myHalfDX;
zc += myHalfDZ;
break;
}
case 6:
{
yc += myHalfDY;
zc += myHalfDZ;
break;
}
case 7:
{
xc += myHalfDX;
yc += myHalfDY;
zc += myHalfDZ;
break;
}
}
switch (j)
{
case 0:
{
xc += 0.25 * myHalfDX;
yc += 0.25 * myHalfDY;
zc += 0.25 * myHalfDZ;
break;
}
case 1:
{
xc += 0.75 * myHalfDX;
yc += 0.25 * myHalfDY;
zc += 0.25 * myHalfDZ;
break;
}
case 2:
{
xc += 0.25 * myHalfDX;
yc += 0.75 * myHalfDY;
zc += 0.25 * myHalfDZ;
break;
}
case 3:
{
xc += 0.75 * myHalfDX;
yc += 0.75 * myHalfDY;
zc += 0.25 * myHalfDZ;
break;
}
case 4:
{
xc += 0.25 * myHalfDX;
yc += 0.25 * myHalfDY;
zc += 0.75 * myHalfDZ;
break;
}
case 5:
{
xc += 0.75 * myHalfDX;
yc += 0.25 * myHalfDY;
zc += 0.75 * myHalfDZ;
break;
}
case 6:
{
xc += 0.25 * myHalfDX;
yc += 0.75 * myHalfDY;
zc += 0.75 * myHalfDZ;
break;
}
case 7:
{
xc += 0.75 * myHalfDX;
yc += 0.75 * myHalfDY;
zc += 0.75 * myHalfDZ;
break;
}
}
}

141
src/Voxel/Voxel_ROctBoolDS.hxx
View File

@ -1,141 +0,0 @@
// Created on: 2008-09-01
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_ROctBoolDS_HeaderFile
#define _Voxel_ROctBoolDS_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Voxel_DS.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
//! A 3D voxel model keeping a boolean flag (1 or 0)
//! value for each voxel, and having an opportunity to split each voxel
//! into 8 sub-voxels recursively.
class Voxel_ROctBoolDS : public Voxel_DS
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_ROctBoolDS();
//! A constructor initializing the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT Voxel_ROctBoolDS(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z);
//! Initialization of the voxel model.
//! (x, y, z) - the start point of the box.
//! (x_len, y_len, z_len) - lengths in x, y and z directions along axes of a co-ordinate system.
//! (nb_x, nb_y, nb_z) - number of splits (voxels) along x, y and z directions.
Standard_EXPORT virtual void Init (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real x_len, const Standard_Real y_len, const Standard_Real z_len, const Standard_Integer nb_x, const Standard_Integer nb_y, const Standard_Integer nb_z) Standard_OVERRIDE;
//! A destructor of the voxel model.
Standard_EXPORT void Destroy();
~Voxel_ROctBoolDS()
{
Destroy();
}
//! The method sets all values equal to 0 (false) and
//! releases the memory.
Standard_EXPORT void SetZero();
//! The method searches voxels with equal-value of sub-voxels
//! and removes them (remaining the value for the voxel).
Standard_EXPORT void OptimizeMemory();
//! Defines a value for voxel with co-ordinates (ix, iy, iz).
//! If the voxel is split into 8 sub-voxels, the split disappears.
//! Initial state of the model is so that all voxels have value 0 (false),
//! and this data doesn't occupy memory.
//! Memory for data is allocating during setting non-zero values (true).
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Boolean data);
//! Defines a value for a sub-voxel of a voxel with co-ordinates (ix, iy, iz).
//! If the voxel is not split into 8 sub-voxels yet, this method splits the voxel.
//! Range of sub-voxels is 0 - 7.
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer ioct1, const Standard_Boolean data);
//! Defines a value for a sub-voxel of a sub-voxel of a voxel with co-ordinates (ix, iy, iz).
//! If the voxel is not split into 8 sub-voxels yet, this method splits the voxel.
//! Range of sub-voxels is 0 - 7.
Standard_EXPORT void Set (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer ioct1, const Standard_Integer ioct2, const Standard_Boolean data);
//! Returns true if the voxel is split into 8 sub-voxels.
Standard_EXPORT Standard_Boolean IsSplit (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
//! Returns the deepness of splits of a voxel.
//! 0 - no splits (::IsSplit() being called would return false).
//! 1 - the voxel is split into 8 sub-voxels.
//! 2 - the voxels is split into 8 sub-voxels,
//! and each of the sub-voxels is split into 8 sub-sub-voxels.
//! 3 - ...
Standard_EXPORT Standard_Integer Deepness (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
//! Returns the value of voxel with co-ordinates (ix, iy, iz).
//! Warning!: the returned value may not coincide with the value of its 8 sub-voxels.
//! Use the method ::IsSplit() to check whether a voxel has sub-voxels.
Standard_EXPORT Standard_Boolean Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
//! Returns the value of a sub-voxel of a voxel with co-ordinates (ix, iy, iz).
//! If the voxel is not split, it returns the value of the voxel.
//! Range of sub-voxels is 0 - 7.
Standard_EXPORT Standard_Boolean Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer ioct1) const;
//! Returns the value of a sub-voxel of a sub-voxel of a voxel with co-ordinates (ix, iy, iz).
//! If the voxel is not split, it returns the value of the voxel.
//! Range of sub-voxels is 0 - 7.
Standard_EXPORT Standard_Boolean Get (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer ioct1, const Standard_Integer ioct2) const;
//! Returns the center point of a sub-voxel with co-ordinates (ix, iy, iz, i).
Standard_EXPORT void GetCenter (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer i, Standard_Real& xc, Standard_Real& yc, Standard_Real& zc) const;
//! Returns the center point of a sub-voxel with co-ordinates (ix, iy, iz, i, j).
Standard_EXPORT void GetCenter (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz, const Standard_Integer i, const Standard_Integer j, Standard_Real& xc, Standard_Real& yc, Standard_Real& zc) const;
protected:
private:
};
#endif // _Voxel_ROctBoolDS_HeaderFile

575
src/Voxel/Voxel_Reader.cxx
View File

@ -1,575 +0,0 @@
// Created on: 2008-08-28
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <OSD_OpenFile.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_ColorDS.hxx>
#include <Voxel_FloatDS.hxx>
#include <Voxel_Reader.hxx>
#include <Voxel_TypeDef.hxx>
#include <Voxel_VoxelFileFormat.hxx>
Voxel_Reader::Voxel_Reader():myBoolVoxels(0),myColorVoxels(0),myFloatVoxels(0)
{
}
Standard_Boolean Voxel_Reader::Read(const TCollection_ExtendedString& file)
{
// Open file in ASCII mode to read header
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
// Read the header
Standard_Byte type; // 0 - bool, 1 - color, 2 - float
Voxel_VoxelFileFormat format;
Standard_Character svoxels[9], sformat[9], stype[9];
if (fscanf(f, "%8s %8s %8s\n", svoxels, sformat, stype) != 3)
{
fclose(f);
return Standard_False;
}
fclose(f);
// Take format, type of voxels.
// Voxels
if (strcmp(svoxels, VOXELS))
return Standard_False;
// Format
if (strcmp(sformat, ASCII) == 0)
format = Voxel_VFF_ASCII;
else if (strcmp(sformat, BINARY) == 0)
format = Voxel_VFF_BINARY;
else
return Standard_False;
// Type of voxels
if (strcmp(stype, BOOL) == 0)
type = 0;
else if (strcmp(stype, COLOR) == 0)
type = 1;
else if (strcmp(stype, FLOAT) == 0)
type = 2;
else
return Standard_False;
// Read the rest
switch (format)
{
case Voxel_VFF_ASCII:
{
switch (type)
{
case 0:
return ReadBoolAsciiVoxels(file);
case 1:
return ReadColorAsciiVoxels(file);
case 2:
return ReadFloatAsciiVoxels(file);
}
}
case Voxel_VFF_BINARY:
{
switch (type)
{
case 0:
return ReadBoolBinaryVoxels(file);
case 1:
return ReadColorBinaryVoxels(file);
case 2:
return ReadFloatBinaryVoxels(file);
}
}
}
// No voxels or no format description is found:
return Standard_False;
}
Standard_Boolean Voxel_Reader::IsBoolVoxels() const
{
return (myBoolVoxels != 0);
}
Standard_Boolean Voxel_Reader::IsColorVoxels() const
{
return (myColorVoxels != 0);
}
Standard_Boolean Voxel_Reader::IsFloatVoxels() const
{
return (myFloatVoxels != 0);
}
Standard_Address Voxel_Reader::GetBoolVoxels() const
{
return myBoolVoxels;
}
Standard_Address Voxel_Reader::GetColorVoxels() const
{
return myColorVoxels;
}
Standard_Address Voxel_Reader::GetFloatVoxels() const
{
return myFloatVoxels;
}
static Standard_Boolean has_slice(const Standard_CString line)
{
Standard_Integer i = 0, nb_spaces = 0;
while (line[i] != '\0')
{
if (line[i] == ' ')
nb_spaces++;
i++;
}
return (nb_spaces == 2);
}
Standard_Boolean Voxel_Reader::ReadBoolAsciiVoxels(const TCollection_ExtendedString& file)
{
// Open file for reading
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
Standard_Character line[65], sx[33], sy[33], sz[33];
// Header: skip it
if (fgets(line, 64, f) == NULL)
{
return Standard_False;
}
// Location, size, number of splits
Standard_Integer nbx = 0, nby = 0, nbz = 0;
Standard_Real x = 0.0, y = 0.0, z = 0.0, xlen = 0.0, ylen = 0.0, zlen = 0.0;
if (fscanf(f, "%32s %32s %32s\n", sx, sy, sz) != 3)
{
fclose(f);
return Standard_False;
}
x = Atof(sx); y = Atof(sy); z = Atof(sz);
if (fscanf(f, "%32s %32s %32s\n", sx, sy, sz) != 3)
{
fclose(f);
return Standard_False;
}
xlen = Atof(sx); ylen = Atof(sy); zlen = Atof(sz);
if (fscanf(f, "%d %d %d\n", &nbx, &nby, &nbz) != 3)
{
fclose(f);
return Standard_False;
}
// Allocate the voxels
myBoolVoxels = (Standard_Address) new Voxel_BoolDS(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
// Data
// Copied from Voxel_BoolDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(nbx * nby * nbz / 8.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 8.0));
// myData[0 .. nb_slices - 1][0 .. 7]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0, value = 0;
while (!feof(f)
&& fgets(line, 64, f) != NULL)
{
if (has_slice(line))
{
if (sscanf(line, "%d %d %d\n", &i1, &i2, &value) != 3)
{
fclose(f);
return Standard_False;
}
}
else
{
if (sscanf(line, "%d %d\n", &i2, &value) != 2)
{
fclose(f);
return Standard_False;
}
}
// Set value
if (!((Standard_Byte**)((Voxel_DS*)myBoolVoxels)->myData)[i1])
{
((Standard_Byte**)((Voxel_DS*)myBoolVoxels)->myData)[i1] =
(Standard_Byte*) calloc(8/*number of bytes in slice*/, sizeof(Standard_Byte));
}
(((Standard_Byte**)((Voxel_DS*)myBoolVoxels)->myData)[i1])[i2] = (Standard_Byte)value;
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Reader::ReadColorAsciiVoxels(const TCollection_ExtendedString& file)
{
// Open file for reading
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
Standard_Character line[65], sx[33], sy[33], sz[33];
// Header: skip it
if (fgets(line, 64, f) == NULL)
{
fclose(f);
return Standard_False;
}
// Location, size, number of splits
Standard_Integer nbx = 0, nby = 0, nbz = 0;
Standard_Real x = 0.0, y = 0.0, z = 0.0, xlen = 0.0, ylen = 0.0, zlen = 0.0;
if (fscanf(f, "%32s %32s %32s\n", sx, sy, sz) != 3)
{
fclose(f);
return Standard_False;
}
x = Atof(sx); y = Atof(sy); z = Atof(sz);
if (fscanf(f, "%32s %32s %32s\n", sx, sy, sz) != 3)
{
fclose(f);
return Standard_False;
}
xlen = Atof(sx); ylen = Atof(sy); zlen = Atof(sz);
if (fscanf(f, "%d %d %d\n", &nbx, &nby, &nbz) != 3)
{
fclose(f);
return Standard_False;
}
// Allocate the voxels
myColorVoxels = (Standard_Address) new Voxel_ColorDS(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
// Data
// Copied from Voxel_ColorDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(nbx * nby * nbz / 2.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 32.0));
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0, value = 0;
while (!feof(f)
&& fgets(line, 64, f) != NULL)
{
if (has_slice(line))
{
if (sscanf(line, "%d %d %d\n", &i1, &i2, &value) != 3)
{
fclose(f);
return Standard_False;
}
}
else
{
if (sscanf(line, "%d %d\n", &i2, &value) != 2)
{
fclose(f);
return Standard_False;
}
}
// Set value
if (!((Standard_Byte**)((Voxel_DS*)myColorVoxels)->myData)[i1])
{
((Standard_Byte**)((Voxel_DS*)myColorVoxels)->myData)[i1] =
(Standard_Byte*) calloc(32/*number of bytes in slice*/, sizeof(Standard_Byte));
}
(((Standard_Byte**)((Voxel_DS*)myColorVoxels)->myData)[i1])[i2] = (Standard_Byte)value;
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Reader::ReadFloatAsciiVoxels(const TCollection_ExtendedString& file)
{
// Open file for reading
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
Standard_Character line[65], sx[33], sy[33], sz[33];
// Header: skip it
if (fgets(line, 64, f) == NULL)
{
fclose(f);
return Standard_False;
}
// Location, size, number of splits
Standard_Integer nbx = 0, nby = 0, nbz = 0;
Standard_Real x = 0.0, y = 0.0, z = 0.0, xlen = 0.0, ylen = 0.0, zlen = 0.0;
if (fscanf(f, "%32s %32s %32s\n", sx, sy, sz) != 3)
{
fclose(f);
return Standard_False;
}
x = Atof(sx); y = Atof(sy); z = Atof(sz);
if (fscanf(f, "%32s %32s %32s\n", sx, sy, sz) != 3)
{
fclose(f);
return Standard_False;
}
xlen = Atof(sx); ylen = Atof(sy); zlen = Atof(sz);
if (fscanf(f, "%d %d %d\n", &nbx, &nby, &nbz) != 3)
{
fclose(f);
return Standard_False;
}
// Allocate the voxels
myFloatVoxels = (Standard_Address) new Voxel_FloatDS(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
// Data
// Copied from Voxel_FloatDS.cxx:
Standard_Integer nb_floats = nbx * nby * nbz;
Standard_Integer nb_slices = RealToInt(ceil(nb_floats / 32.0)); // 32 values in 1 slice
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
Standard_ShortReal value = 0.0;
while (!feof(f)
&& fgets(line, 64, f) != NULL)
{
if (has_slice(line))
{
if (sscanf(line, "%d %d %64s\n", &i1, &i2, line) != 3)
{
fclose(f);
return Standard_False;
}
}
else
{
if (sscanf(line, "%d %64s\n", &i2, line) != 2)
{
fclose(f);
return Standard_False;
}
}
value = (Standard_ShortReal)Atof(line);
// Set value
if (!((Standard_ShortReal**)((Voxel_DS*)myFloatVoxels)->myData)[i1])
{
((Standard_ShortReal**)((Voxel_DS*)myFloatVoxels)->myData)[i1] =
(Standard_ShortReal*) calloc(32/*number of floats in slice*/, sizeof(Standard_ShortReal));
}
(((Standard_ShortReal**)((Voxel_DS*)myFloatVoxels)->myData)[i1])[i2] = value;
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Reader::ReadBoolBinaryVoxels(const TCollection_ExtendedString& file)
{
// Open file for reading
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
// Header: skip it
Standard_Character line[65];
if (fgets(line, 64, f) == NULL)
{
fclose(f);
return Standard_False;
}
// Location, size, number of splits
Standard_Integer nbx = 0, nby = 0, nbz = 0;
Standard_Real x = 0.0, y = 0.0, z = 0.0, xlen = 0.0, ylen = 0.0, zlen = 0.0;
if (fread(&x, sizeof(Standard_Real), 1, f) != 1
|| fread(&y, sizeof(Standard_Real), 1, f) != 1
|| fread(&z, sizeof(Standard_Real), 1, f) != 1
|| fread(&xlen, sizeof(Standard_Real), 1, f) != 1
|| fread(&ylen, sizeof(Standard_Real), 1, f) != 1
|| fread(&zlen, sizeof(Standard_Real), 1, f) != 1
|| fread(&nbx, sizeof(Standard_Integer), 1, f) != 1
|| fread(&nby, sizeof(Standard_Integer), 1, f) != 1
|| fread(&nbz, sizeof(Standard_Integer), 1, f) != 1)
{
fclose(f);
return Standard_False;
}
// Allocate the voxels
myBoolVoxels = (Standard_Address) new Voxel_BoolDS(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
// Data
// Copied from Voxel_BoolDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(nbx * nby * nbz / 8.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 8.0));
// myData[0 .. nb_slices - 1][0 .. 7]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0, value = 0;
while (!feof(f)
&& fread(&i1, sizeof(Standard_Integer), 1, f) == 1
&& fread(&i2, sizeof(Standard_Integer), 1, f) == 1
&& fread(&value, sizeof(Standard_Byte), 1, f) == 1)
{
// Set value
if (!((Standard_Byte**)((Voxel_DS*)myBoolVoxels)->myData)[i1])
{
((Standard_Byte**)((Voxel_DS*)myBoolVoxels)->myData)[i1] =
(Standard_Byte*) calloc(8/*number of bytes in slice*/, sizeof(Standard_Byte));
}
(((Standard_Byte**)((Voxel_DS*)myBoolVoxels)->myData)[i1])[i2] = (Standard_Byte)value;
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Reader::ReadColorBinaryVoxels(const TCollection_ExtendedString& file)
{
// Open file for reading
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
// Header: skip it
Standard_Character line[65];
if (fgets(line, 64, f) == NULL)
{
fclose(f);
return Standard_False;
}
// Location, size, number of splits
Standard_Integer nbx = 0, nby = 0, nbz = 0;
Standard_Real x = 0.0, y = 0.0, z = 0.0, xlen = 0.0, ylen = 0.0, zlen = 0.0;
if (fread(&x, sizeof(Standard_Real), 1, f) != 1
|| fread(&y, sizeof(Standard_Real), 1, f) != 1
|| fread(&z, sizeof(Standard_Real), 1, f) != 1
|| fread(&xlen, sizeof(Standard_Real), 1, f) != 1
|| fread(&ylen, sizeof(Standard_Real), 1, f) != 1
|| fread(&zlen, sizeof(Standard_Real), 1, f) != 1
|| fread(&nbx, sizeof(Standard_Integer), 1, f) != 1
|| fread(&nby, sizeof(Standard_Integer), 1, f) != 1
|| fread(&nbz, sizeof(Standard_Integer), 1, f) != 1)
{
fclose(f);
return Standard_False;
}
// Allocate the voxels
myColorVoxels = (Standard_Address) new Voxel_ColorDS(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
// Data
// Copied from Voxel_ColorDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(nbx * nby * nbz / 2.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 32.0));
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0, value = 0;
while (!feof(f)
&& fread(&i1, sizeof(Standard_Integer), 1, f) == 1
&& fread(&i2, sizeof(Standard_Integer), 1, f) == 1
&& fread(&value, sizeof(Standard_Byte), 1, f) == 1)
{
// Set value
if (!((Standard_Byte**)((Voxel_DS*)myColorVoxels)->myData)[i1])
{
((Standard_Byte**)((Voxel_DS*)myColorVoxels)->myData)[i1] =
(Standard_Byte*) calloc(32/*number of bytes in slice*/, sizeof(Standard_Byte));
}
(((Standard_Byte**)((Voxel_DS*)myColorVoxels)->myData)[i1])[i2] = (Standard_Byte)value;
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Reader::ReadFloatBinaryVoxels(const TCollection_ExtendedString& file)
{
// Open file for reading
FILE* f = OSD_OpenFile(file, "r");
if (!f)
return Standard_False;
// Header: skip it
Standard_Character line[65];
if (fgets(line, 64, f) == NULL)
{
fclose(f);
return Standard_False;
}
// Location, size, number of splits
Standard_Integer nbx = 0, nby = 0, nbz = 0;
Standard_Real x = 0.0, y = 0.0, z = 0.0, xlen = 0.0, ylen = 0.0, zlen = 0.0;
if (fread(&x, sizeof(Standard_Real), 1, f) != 1
|| fread(&y, sizeof(Standard_Real), 1, f) != 1
|| fread(&z, sizeof(Standard_Real), 1, f) != 1
|| fread(&xlen, sizeof(Standard_Real), 1, f) != 1
|| fread(&ylen, sizeof(Standard_Real), 1, f) != 1
|| fread(&zlen, sizeof(Standard_Real), 1, f) != 1
|| fread(&nbx, sizeof(Standard_Integer), 1, f) != 1
|| fread(&nby, sizeof(Standard_Integer), 1, f) != 1
|| fread(&nbz, sizeof(Standard_Integer), 1, f) != 1)
{
fclose(f);
return Standard_False;
}
// Allocate the voxels
myFloatVoxels = (Standard_Address) new Voxel_FloatDS(x, y, z, xlen, ylen, zlen, nbx, nby, nbz);
// Data
// Copied from Voxel_FloatDS.cxx:
Standard_Integer nb_floats = nbx * nby * nbz;
Standard_Integer nb_slices = RealToInt(ceil(nb_floats / 32.0)); // 32 values in 1 slice
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
Standard_ShortReal value = 0.0;
while (!feof(f)
&& fread(&i1, sizeof(Standard_Integer), 1, f) == 1
&& fread(&i2, sizeof(Standard_Integer), 1, f) == 1
&& fread(&value, sizeof(Standard_ShortReal), 1, f) == 1)
{
// Set value
if (!((Standard_ShortReal**)((Voxel_DS*)myFloatVoxels)->myData)[i1])
{
((Standard_ShortReal**)((Voxel_DS*)myFloatVoxels)->myData)[i1] =
(Standard_ShortReal*) calloc(32/*number of floats in slice*/, sizeof(Standard_ShortReal));
}
(((Standard_ShortReal**)((Voxel_DS*)myFloatVoxels)->myData)[i1])[i2] = value;
}
}
fclose(f);
return Standard_True;
}

105
src/Voxel/Voxel_Reader.hxx
View File

@ -1,105 +0,0 @@
// Created on: 2008-08-28
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_Reader_HeaderFile
#define _Voxel_Reader_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
class TCollection_ExtendedString;
//! Reads a cube of voxels from disk.
//! Beware, a caller of the reader is responsible for deletion of the read voxels.
class Voxel_Reader
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_Reader();
//! Reads the voxels from disk
Standard_EXPORT Standard_Boolean Read (const TCollection_ExtendedString& file);
//! Informs the user about the type of voxels he has read.
Standard_EXPORT Standard_Boolean IsBoolVoxels() const;
//! Informs the user about the type of voxels he has read.
Standard_EXPORT Standard_Boolean IsColorVoxels() const;
//! Informs the user about the type of voxels he has read.
Standard_EXPORT Standard_Boolean IsFloatVoxels() const;
//! Returns a pointer to the read 1bit voxels.
Standard_EXPORT Standard_Address GetBoolVoxels() const;
//! Returns a pointer to the read 4bit voxels.
Standard_EXPORT Standard_Address GetColorVoxels() const;
//! Returns a pointer to the read 4bytes voxels.
Standard_EXPORT Standard_Address GetFloatVoxels() const;
protected:
private:
//! Reads 1bit voxels from disk in ASCII format.
Standard_EXPORT Standard_Boolean ReadBoolAsciiVoxels (const TCollection_ExtendedString& file);
//! Reads 4bit voxels from disk in ASCII format.
Standard_EXPORT Standard_Boolean ReadColorAsciiVoxels (const TCollection_ExtendedString& file);
//! Reads 4bytes voxels from disk in ASCII format.
Standard_EXPORT Standard_Boolean ReadFloatAsciiVoxels (const TCollection_ExtendedString& file);
//! Reads 1bit voxels from disk in BINARY format.
Standard_EXPORT Standard_Boolean ReadBoolBinaryVoxels (const TCollection_ExtendedString& file);
//! Reads 4bit voxels from disk in BINARY format.
Standard_EXPORT Standard_Boolean ReadColorBinaryVoxels (const TCollection_ExtendedString& file);
//! Reads 4bytes voxels from disk in BINARY format.
Standard_EXPORT Standard_Boolean ReadFloatBinaryVoxels (const TCollection_ExtendedString& file);
Standard_Address myBoolVoxels;
Standard_Address myColorVoxels;
Standard_Address myFloatVoxels;
};
#endif // _Voxel_Reader_HeaderFile

581
src/Voxel/Voxel_Selector.cxx
View File

@ -1,581 +0,0 @@
// Created on: 2008-07-30
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <gp_Dir.hxx>
#include <gp_Lin.hxx>
#include <gp_Pln.hxx>
#include <gp_Pnt.hxx>
#include <IntAna_IntConicQuad.hxx>
#include <IntAna_Quadric.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <V3d_View.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_ColorDS.hxx>
#include <Voxel_ROctBoolDS.hxx>
#include <Voxel_Selector.hxx>
Voxel_Selector::Voxel_Selector():myVoxels(0)
{
}
Voxel_Selector::Voxel_Selector(const Handle(V3d_View)& view):myView(view),myVoxels(0)
{
}
void Voxel_Selector::Init(const Handle(V3d_View)& view)
{
myView = view;
}
void Voxel_Selector::SetVoxels(const Voxel_BoolDS& voxels)
{
myIsBool = 1;
myVoxels = (void*) &voxels;
}
void Voxel_Selector::SetVoxels(const Voxel_ColorDS& voxels)
{
myIsBool = 0;
myVoxels = (void*) &voxels;
}
void Voxel_Selector::SetVoxels(const Voxel_ROctBoolDS& voxels)
{
myIsBool = 2;
myVoxels = (void*) &voxels;
}
// This function is copied from ViewerTest_RelationCommands.cxx
static Standard_Boolean ComputeIntersection(const gp_Lin& L,const gp_Pln& ThePl, gp_Pnt& TheInter)
{
static IntAna_Quadric TheQuad;
TheQuad.SetQuadric(ThePl);
static IntAna_IntConicQuad QQ;
QQ.Perform(L,TheQuad);
if(QQ.IsDone()){
if(QQ.NbPoints()>0){
TheInter = QQ.Point(1);
return Standard_True;
}
}
return Standard_False;
}
static inline Standard_Integer GetIVoxel(const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz,
const Standard_Integer nbx, const Standard_Integer nbxy)
{
return ix + iy * nbx + iz * nbxy;
}
static inline Standard_Boolean Get(const Standard_Address voxels, const Standard_Integer isBool,
const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz)
{
switch (isBool)
{
case 0:
return ((Voxel_ColorDS*) voxels)->Get(ix, iy, iz) > 0;
case 1:
return ((Voxel_BoolDS*) voxels)->Get(ix, iy, iz);
case 2:
{
Standard_Integer deepness = ((Voxel_ROctBoolDS*) voxels)->Deepness(ix, iy, iz);
switch (deepness)
{
case 0:
return ((Voxel_ROctBoolDS*) voxels)->Get(ix, iy, iz);
case 1:
{
for (Standard_Integer i = 0; i < 8; i++)
{
if (((Voxel_ROctBoolDS*) voxels)->Get(ix, iy, iz, i) == Standard_True)
return Standard_True;
}
break;
}
case 2:
{
for (Standard_Integer i = 0; i < 8; i++)
{
for (Standard_Integer j = 0; j < 8; j++)
{
if (((Voxel_ROctBoolDS*) voxels)->Get(ix, iy, iz, i, j) == Standard_True)
return Standard_True;
}
}
break;
}
}
}
}
return Standard_False;
}
Standard_Boolean Voxel_Selector::Detect(const Standard_Integer winx, const Standard_Integer winy,
Standard_Integer& ixdetect, Standard_Integer& iydetect, Standard_Integer& izdetect)
{
ixdetect = -1; iydetect = -1; izdetect = -1;
if (myView.IsNull() || !myVoxels)
return Standard_False;
Voxel_DS* ds = 0;
switch (myIsBool)
{
case 0:
ds = (Voxel_ColorDS*) myVoxels;
break;
case 1:
ds = (Voxel_BoolDS*) myVoxels;
break;
case 2:
ds = (Voxel_ROctBoolDS*) myVoxels;
break;
}
Standard_Integer nbx = ds->GetNbX(), nby = ds->GetNbY(), nbz = ds->GetNbZ(), nbxy = nbx * nby;
// Construct a line perpendicular to the screen
Standard_Real eyex, eyey, eyez, nx, ny, nz;
myView->Convert(winx, winy, eyex, eyey, eyez);
myView->Proj(nx, ny, nz);
gp_Pnt peye(eyex, eyey, eyez);
gp_Lin line(peye, gp_Dir(nx, ny, nz));
// Find the first voxel meeting the line at entrance to the cube of voxels.
// Construct planes of the cube of voxels
Standard_Real xstart = ds->GetX(), ystart = ds->GetY(), zstart = ds->GetZ();
Standard_Real xlen = ds->GetXLen(), ylen = ds->GetYLen(), zlen = ds->GetZLen();
Standard_Real xend = xstart + xlen, yend = ystart + ylen, zend = zstart + zlen;
gp_Pln xplane_minus(gp_Pnt(xstart, ystart, zstart), -gp::DX());
gp_Pln xplane_plus (gp_Pnt(xend, ystart, zstart), gp::DX());
gp_Pln yplane_minus(gp_Pnt(xstart, ystart, zstart), -gp::DY());
gp_Pln yplane_plus (gp_Pnt(xstart, yend, zstart), gp::DY());
gp_Pln zplane_minus(gp_Pnt(xstart, ystart, zstart), -gp::DZ());
gp_Pln zplane_plus (gp_Pnt(xstart, ystart, zend), gp::DZ());
// Intersect the planes with the line.
gp_Pnt pintersection, p;
Standard_Real depth = DBL_MAX, d;
Standard_Integer iplane = -1; // not found
if (ComputeIntersection(line, xplane_minus, p)) // -X
{
if (p.Y() >= ystart && p.Y() <= yend &&
p.Z() >= zstart && p.Z() <= zend)
{
p.SetX(xstart);
depth = peye.SquareDistance(p);
iplane = 0;
pintersection = p;
}
}
if (ComputeIntersection(line, xplane_plus, p)) // +X
{
if (p.Y() >= ystart && p.Y() <= yend &&
p.Z() >= zstart && p.Z() <= zend)
{
d = peye.SquareDistance(p);
if (d < depth)
{
p.SetX(xend);
depth = d;
iplane = 1;
pintersection = p;
}
}
}
if (ComputeIntersection(line, yplane_minus, p)) // -Y
{
if (p.X() >= xstart && p.X() <= xend &&
p.Z() >= zstart && p.Z() <= zend)
{
d = peye.SquareDistance(p);
if (d < depth)
{
p.SetY(ystart);
depth = d;
iplane = 2;
pintersection = p;
}
}
}
if (ComputeIntersection(line, yplane_plus, p)) // +Y
{
if (p.X() >= xstart && p.X() <= xend &&
p.Z() >= zstart && p.Z() <= zend)
{
d = peye.SquareDistance(p);
if (d < depth)
{
p.SetY(yend);
depth = d;
iplane = 3;
pintersection = p;
}
}
}
if (ComputeIntersection(line, zplane_minus, p)) // -Z
{
if (p.X() >= xstart && p.X() <= xend &&
p.Y() >= ystart && p.Y() <= yend)
{
d = peye.SquareDistance(p);
if (d < depth)
{
p.SetZ(zstart);
depth = d;
iplane = 4;
pintersection = p;
}
}
}
if (ComputeIntersection(line, zplane_plus, p)) // +Z
{
if (p.X() >= xstart && p.X() <= xend &&
p.Y() >= ystart && p.Y() <= yend)
{
d = peye.SquareDistance(p);
if (d < depth)
{
p.SetZ(zend);
depth = d;
iplane = 5;
pintersection = p;
}
}
}
// Find the voxel on the detected plane
if (iplane == -1)
return Standard_False;
Standard_Integer ix, iy, iz;
if (!ds->GetVoxel(pintersection.X(), pintersection.Y(), pintersection.Z(), ix, iy, iz))
return Standard_False;
ixdetect = ix; iydetect = iy; izdetect = iz;
// Find a non-zero voxel at the line
Standard_Real xmin = xlen / Standard_Real(nbx),
ymin = ylen / Standard_Real(nby),
zmin = zlen / Standard_Real(nbz),
vmin = sqrt(xmin * xmin + ymin * ymin + zmin * zmin) / 2.0;
Standard_Real xc, yc, zc, dist, distmin = DBL_MAX;
TColStd_MapOfInteger passed;
while (!Get(myVoxels, myIsBool, ixdetect, iydetect, izdetect))
{
// Memorize already checked voxels
if (!passed.Add(GetIVoxel(ixdetect, iydetect, izdetect, nbx, nbxy)))
return Standard_False;
distmin = DBL_MAX;
ix = ixdetect; iy = iydetect; iz = izdetect;
//1: -X neighbour
if (ix - 1 >= 0 && !passed.Contains(GetIVoxel(ix - 1, iy, iz, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy; izdetect = iz;
distmin = dist;
}
}
//2: +X neighbour
if (ix + 1 < nbx && !passed.Contains(GetIVoxel(ix + 1, iy, iz, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy; izdetect = iz;
distmin = dist;
}
}
//3: -Y neighbour
if (iy - 1 >= 0 && !passed.Contains(GetIVoxel(ix, iy - 1, iz, nbx, nbxy)))
{
ds->GetCenter(ix, iy - 1, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy - 1; izdetect = iz;
distmin = dist;
}
}
//4: +Y neighbour
if (iy + 1 < nby && !passed.Contains(GetIVoxel(ix, iy + 1, iz, nbx, nbxy)))
{
ds->GetCenter(ix, iy + 1, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy + 1; izdetect = iz;
distmin = dist;
}
}
//5: -Z neighbour
if (iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix, iy, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix, iy, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy; izdetect = iz - 1;
distmin = dist;
}
}
//6: +Z neighbour
if (iz + 1 < nbz && !passed.Contains(GetIVoxel(ix, iy, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix, iy, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy; izdetect = iz + 1;
distmin = dist;
}
}
// Diagonal voxels
//7: -X-Y neighbour
if (ix - 1 >= 0 && iy - 1 >= 0 && !passed.Contains(GetIVoxel(ix - 1, iy - 1, iz, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy - 1, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy - 1; izdetect = iz;
distmin = dist;
}
}
//8: -X-Z neighbour
if (ix - 1 >= 0 && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix - 1, iy, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy; izdetect = iz - 1;
distmin = dist;
}
}
//9: -Y-Z neighbour
if (iy - 1 >= 0 && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix, iy - 1, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix, iy - 1, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy - 1; izdetect = iz - 1;
distmin = dist;
}
}
//10: +X-Y neighbour
if (ix + 1 < nbx && iy - 1 >= 0 && !passed.Contains(GetIVoxel(ix + 1, iy - 1, iz, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy - 1, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy - 1; izdetect = iz;
distmin = dist;
}
}
//11: +X-Z neighbour
if (ix + 1 < nbx && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix + 1, iy, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy; izdetect = iz - 1;
distmin = dist;
}
}
//12: +Y-Z neighbour
if (iy + 1 < nby && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix, iy + 1, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix, iy + 1, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy + 1; izdetect = iz - 1;
distmin = dist;
}
}
//13: -X+Y neighbour
if (ix - 1 >= 0 && iy + 1 < nby && !passed.Contains(GetIVoxel(ix - 1, iy + 1, iz, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy + 1, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy + 1; izdetect = iz;
distmin = dist;
}
}
//14: -X+Z neighbour
if (ix - 1 >= 0 && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix - 1, iy, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy; izdetect = iz + 1;
distmin = dist;
}
}
//15: -Y+Z neighbour
if (iy - 1 >= 0 && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix, iy - 1, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix, iy - 1, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy - 1; izdetect = iz + 1;
distmin = dist;
}
}
//16: +X+Y neighbour
if (ix + 1 < nbx && iy + 1 < nby && !passed.Contains(GetIVoxel(ix + 1, iy + 1, iz, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy + 1, iz, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy + 1; izdetect = iz;
distmin = dist;
}
}
//17: +X+Z neighbour
if (ix + 1 < nbx && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix + 1, iy, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy; izdetect = iz + 1;
distmin = dist;
}
}
//18: +Y+Z neighbour
if (iy + 1 < nby && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix, iy + 1, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix, iy + 1, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix; iydetect = iy + 1; izdetect = iz + 1;
distmin = dist;
}
}
// Farest neighbours
//19: -X-Y-Z neighbour
if (ix - 1 >= 0 && iy - 1 >= 0 && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix - 1, iy - 1, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy - 1, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy - 1; izdetect = iz - 1;
distmin = dist;
}
}
//20: +X-Y-Z neighbour
if (ix + 1 < nbx && iy - 1 >= 0 && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix + 1, iy - 1, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy - 1, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy - 1; izdetect = iz - 1;
distmin = dist;
}
}
//21: -X+Y-Z neighbour
if (ix - 1 >= 0 && iy + 1 < nby && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix - 1, iy + 1, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy + 1, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy + 1; izdetect = iz - 1;
distmin = dist;
}
}
//22: -X-Y+Z neighbour
if (ix - 1 >= 0 && iy - 1 >= 0 && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix - 1, iy - 1, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy - 1, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy - 1; izdetect = iz + 1;
distmin = dist;
}
}
//23: +X+Y-Z neighbour
if (ix + 1 < nbx && iy + 1 < nby && iz - 1 >= 0 && !passed.Contains(GetIVoxel(ix + 1, iy + 1, iz - 1, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy + 1, iz - 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy + 1; izdetect = iz - 1;
distmin = dist;
}
}
//24: +X-Y+Z neighbour
if (ix + 1 < nbx && iy - 1 >= 0 && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix + 1, iy - 1, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy - 1, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy - 1; izdetect = iz + 1;
distmin = dist;
}
}
//25: -X+Y+Z neighbour
if (ix - 1 >= 0 && iy + 1 < nby && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix - 1, iy + 1, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix - 1, iy + 1, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix - 1; iydetect = iy + 1; izdetect = iz + 1;
distmin = dist;
}
}
//26: +X+Y+Z neighbour
if (ix + 1 < nbx && iy + 1 < nby && iz + 1 < nbz && !passed.Contains(GetIVoxel(ix + 1, iy + 1, iz + 1, nbx, nbxy)))
{
ds->GetCenter(ix + 1, iy + 1, iz + 1, xc, yc, zc);
dist = line.Distance(gp_Pnt(xc, yc, zc));
if (dist < vmin && dist < distmin)
{
ixdetect = ix + 1; iydetect = iy + 1; izdetect = iz + 1;
distmin = dist;
}
}
} // End of while (zero-voxel...
if (!Get(myVoxels, myIsBool, ixdetect, iydetect, izdetect))
return Standard_False;
return Standard_True;
}

90
src/Voxel/Voxel_Selector.hxx
View File

@ -1,90 +0,0 @@
// Created on: 2008-07-30
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_Selector_HeaderFile
#define _Voxel_Selector_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class V3d_View;
class Voxel_BoolDS;
class Voxel_ColorDS;
class Voxel_ROctBoolDS;
//! Detects voxels in the viewer 3d under the mouse cursor.
class Voxel_Selector
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_Selector();
//! A constructor of the selector,
//! which initializes the classes
//! by a view, where the user selects the voxels.
Standard_EXPORT Voxel_Selector(const Handle(V3d_View)& view);
//! Initializes the selector by a view,
//! where the user selects the voxels.
Standard_EXPORT void Init (const Handle(V3d_View)& view);
//! Defines the voxels (1bit).
Standard_EXPORT void SetVoxels (const Voxel_BoolDS& voxels);
//! Defines the voxels (4bit).
Standard_EXPORT void SetVoxels (const Voxel_ColorDS& voxels);
//! Defines the voxels (1bit recursive splitting).
Standard_EXPORT void SetVoxels (const Voxel_ROctBoolDS& voxels);
//! Detects a voxel under the mouse cursor.
Standard_EXPORT Standard_Boolean Detect (const Standard_Integer winx, const Standard_Integer winy, Standard_Integer& ix, Standard_Integer& iy, Standard_Integer& iz);
protected:
private:
Handle(V3d_View) myView;
Standard_Address myVoxels;
Standard_Integer myIsBool;
};
#endif // _Voxel_Selector_HeaderFile

32
src/Voxel/Voxel_SplitData.cxx
View File

@ -1,32 +0,0 @@
// Created on: 2008-09-01
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <Voxel_SplitData.hxx>
Voxel_SplitData::Voxel_SplitData():myValues(0),mySplitData(0)
{
}
Standard_Address& Voxel_SplitData::GetValues()
{
return myValues;
}
Standard_Address& Voxel_SplitData::GetSplitData()
{
return mySplitData;
}

70
src/Voxel/Voxel_SplitData.hxx
View File

@ -1,70 +0,0 @@
// Created on: 2008-09-01
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_SplitData_HeaderFile
#define _Voxel_SplitData_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
//! A container of split information.
//! An instance of this class is used as a slice
//! in inner representation of recursive octtree voxels.
class Voxel_SplitData
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_SplitData();
//! Gives access to the values.
Standard_EXPORT Standard_Address& GetValues();
//! Gives access to the next split data.
Standard_EXPORT Standard_Address& GetSplitData();
protected:
private:
Standard_Address myValues;
Standard_Address mySplitData;
};
#endif // _Voxel_SplitData_HeaderFile

53
src/Voxel/Voxel_TypeDef.hxx
View File

@ -1,53 +0,0 @@
// Copyright (c) 1999-2014 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.
#ifndef _VOXEL_TYPEDEF_HXX_
#define _VOXEL_TYPEDEF_HXX_
// Basic data types
typedef struct
{
Standard_Integer ix;
Standard_Integer iy;
Standard_Integer iz;
} iXYZ;
// Maps and Tables
inline Standard_Integer HashCode(const iXYZ& me, const Standard_Integer upper)
{
return (Abs(me.ix + me.iy + me.iz) % upper) + 1;
}
inline Standard_Boolean IsEqual(const iXYZ& one, const iXYZ& two)
{
return one.ix == two.ix && one.iy == two.iy && one.iz == two.iz;
}
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<iXYZ, Standard_Integer> iXYZIndex;
typedef NCollection_DataMap<iXYZ, Standard_Byte> iXYZBool;
// Defines
#define VOXELS "Voxels"
#define ASCII "Ascii"
#define BINARY "Binary"
#define BOOL "Bool"
#define COLOR "Color"
#define FLOAT "Float"
#endif // _VOXEL_TYPEDEF_HXX_

129
src/Voxel/Voxel_VisData.h
View File

@ -1,129 +0,0 @@
/*
Copyright (c) 1999-2014 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.
*/
#ifndef _VOXEL_VISDATA_H_
#define _VOXEL_VISDATA_H_
#include <Quantity_Color.hxx>
#include <Quantity_HArray1OfColor.hxx>
#include <TShort_HArray1OfShortReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColgp_HArray1OfDir.hxx>
#include <Poly_Triangulation.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_ColorDS.hxx>
#include <Voxel_ROctBoolDS.hxx>
#include <Voxel_VoxelDisplayMode.hxx>
enum VoxelDirection
{
None,
Xminus,
Xplus,
Yminus,
Yplus,
Zminus,
Zplus
};
typedef struct
{
/* Display mode */
Voxel_VoxelDisplayMode myDisplayMode;
/* Range of displayed values */
/* BoolDS */
/* No range */
/* ColorDS */
Standard_Byte myColorMinValue;
Standard_Byte myColorMaxValue;
/* Range of displayed size */
Standard_Real myDisplayedXMin;
Standard_Real myDisplayedXMax;
Standard_Real myDisplayedYMin;
Standard_Real myDisplayedYMax;
Standard_Real myDisplayedZMin;
Standard_Real myDisplayedZMax;
/* Colors */
Quantity_Color myColor;
Handle(Quantity_HArray1OfColor) myColors;
/* Size, width... */
Standard_Real myPointSize;
Standard_Integer myQuadrangleSize; /* 0% .. 100% */
Standard_Byte mySmoothPoints;
/* Transparency */
Standard_Real myTransparency;
/* GL lists of each display mode */
/* BoolDS */
/* POINTS */
Standard_Integer myBoolPointsList;
Standard_Byte myBoolPointsFirst;
/* NEAREST POINTS */
Standard_Integer myBoolNearestPointsList[7];
Standard_Byte myBoolNearestPointsFirst;
/* ColorDS */
/* POINTS */
Standard_Integer myColorPointsList;
Standard_Byte myColorPointsFirst;
/* NEAREST POINTS */
Standard_Integer myColorNearestPointsList[7];
Standard_Byte myColorNearestPointsFirst;
/* ROctBoolDS */
/* POINTS */
Standard_Integer myROctBoolPointsList;
Standard_Byte myROctBoolPointsFirst;
/* NEAREST POINTS */
Standard_Integer myROctBoolNearestPointsList[7];
Standard_Byte myROctBoolNearestPointsFirst;
/* TRIANGULATION */
Standard_Integer myTriangulationList;
/* Usage of GL lists */
Standard_Byte myUsageOfGLlists;
/* Degenerate mode */
Standard_Byte myDegenerateMode;
/* Highlighted voxel */
Standard_Integer myHighlightx;
Standard_Integer myHighlighty;
Standard_Integer myHighlightz;
} DisplayData;
typedef struct
{
// Voxels
Voxel_BoolDS* myBoolVoxels;
Voxel_ColorDS* myColorVoxels;
Voxel_ROctBoolDS* myROctBoolVoxels;
// Triangulation
Handle(Poly_Triangulation) myTriangulation;
Handle(TColgp_HArray1OfDir) myNormalsOfNodes;
// Display
DisplayData myDisplay;
} Voxel_VisData;
#endif // _VOXEL_VISDATA_H_

28
src/Voxel/Voxel_VoxelDisplayMode.hxx
View File

@ -1,28 +0,0 @@
// Created on: 2008-05-04
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_VoxelDisplayMode_HeaderFile
#define _Voxel_VoxelDisplayMode_HeaderFile
enum Voxel_VoxelDisplayMode
{
Voxel_VDM_POINTS,
Voxel_VDM_NEARESTPOINTS,
Voxel_VDM_BOXES,
Voxel_VDM_NEARESTBOXES
};
#endif // _Voxel_VoxelDisplayMode_HeaderFile

26
src/Voxel/Voxel_VoxelFileFormat.hxx
View File

@ -1,26 +0,0 @@
// Created on: 2008-05-04
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_VoxelFileFormat_HeaderFile
#define _Voxel_VoxelFileFormat_HeaderFile
enum Voxel_VoxelFileFormat
{
Voxel_VFF_ASCII,
Voxel_VFF_BINARY
};
#endif // _Voxel_VoxelFileFormat_HeaderFile

442
src/Voxel/Voxel_Writer.cxx
View File

@ -1,442 +0,0 @@
// Created on: 2008-08-28
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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 <OSD_OpenFile.hxx>
#include <Precision.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <Voxel_BoolDS.hxx>
#include <Voxel_ColorDS.hxx>
#include <Voxel_FloatDS.hxx>
#include <Voxel_TypeDef.hxx>
#include <Voxel_Writer.hxx>
Voxel_Writer::Voxel_Writer():myFormat(Voxel_VFF_ASCII),myBoolVoxels(0),myColorVoxels(0),myFloatVoxels(0)
{
}
void Voxel_Writer::SetFormat(const Voxel_VoxelFileFormat format)
{
myFormat = format;
}
void Voxel_Writer::SetVoxels(const Voxel_BoolDS& voxels)
{
myBoolVoxels = (Standard_Address) &voxels;
myColorVoxels = 0;
myFloatVoxels = 0;
}
void Voxel_Writer::SetVoxels(const Voxel_ColorDS& voxels)
{
myBoolVoxels = 0;
myColorVoxels = (Standard_Address) &voxels;
myFloatVoxels = 0;
}
void Voxel_Writer::SetVoxels(const Voxel_FloatDS& voxels)
{
myBoolVoxels = 0;
myColorVoxels = 0;
myFloatVoxels = (Standard_Address) &voxels;
}
Standard_Boolean Voxel_Writer::Write(const TCollection_ExtendedString& file) const
{
switch (myFormat)
{
case Voxel_VFF_ASCII:
{
if (myBoolVoxels)
return WriteBoolAsciiVoxels(file);
else if (myColorVoxels)
return WriteColorAsciiVoxels(file);
else if (myFloatVoxels)
return WriteFloatAsciiVoxels(file);
}
case Voxel_VFF_BINARY:
{
if (myBoolVoxels)
return WriteBoolBinaryVoxels(file);
else if (myColorVoxels)
return WriteColorBinaryVoxels(file);
else if (myFloatVoxels)
return WriteFloatBinaryVoxels(file);
}
}
// No voxels or no format description is found:
return Standard_False;
}
Standard_Boolean Voxel_Writer::WriteBoolAsciiVoxels(const TCollection_ExtendedString& file) const
{
Voxel_BoolDS* ds = (Voxel_BoolDS*) myBoolVoxels;
if (!ds->myData)
return Standard_False;
// Open file for writing
FILE* f = OSD_OpenFile(file, "w+");
if (!f)
return Standard_False;
// Header: file format, type of voxels
fprintf(f, VOXELS);
fprintf(f, " ");
fprintf(f, ASCII);
fprintf(f, " ");
fprintf(f, BOOL);
fprintf(f, "\n");
// Location, size, number of splits
fprintf(f, "%g %g %g\n", ds->GetX(), ds->GetY(), ds->GetZ());
fprintf(f, "%g %g %g\n", ds->GetXLen(), ds->GetYLen(), ds->GetZLen());
fprintf(f, "%d %d %d\n", ds->GetNbX(), ds->GetNbY(), ds->GetNbZ());
// Data
// Copied from Voxel_BoolDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(ds->GetNbX() * ds->GetNbY() * ds->GetNbZ() / 8.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 8.0));
// myData[0 .. nb_slices - 1][0 .. 7]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
for (i1 = 0; i1 < nb_slices; i1++)
{
if (((Standard_Byte**)ds->myData)[i1])
{
Standard_Boolean has_value = Standard_False;
fprintf(f, "%d ", i1); // index of slice
for (i2 = 0; i2 < 8; i2++)
{
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)ds->myData)[i1])[i2];
if (value)
{
has_value = Standard_True;
fprintf(f, "%d %d\n", i2, value);
}
}
if (!has_value)
{
fprintf(f, "0 0\n");
}
}
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Writer::WriteColorAsciiVoxels(const TCollection_ExtendedString& file) const
{
Voxel_ColorDS* ds = (Voxel_ColorDS*) myColorVoxels;
if (!ds->myData)
return Standard_False;
// Open file for writing
FILE* f = OSD_OpenFile(file, "w+");
if (!f)
return Standard_False;
// Header: file format, type of voxels
fprintf(f, VOXELS);
fprintf(f, " ");
fprintf(f, ASCII);
fprintf(f, " ");
fprintf(f, COLOR);
fprintf(f, "\n");
// Location, size, number of splits
fprintf(f, "%g %g %g\n", ds->GetX(), ds->GetY(), ds->GetZ());
fprintf(f, "%g %g %g\n", ds->GetXLen(), ds->GetYLen(), ds->GetZLen());
fprintf(f, "%d %d %d\n", ds->GetNbX(), ds->GetNbY(), ds->GetNbZ());
// Data
// Copied from Voxel_ColorDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(ds->GetNbX() * ds->GetNbY() * ds->GetNbZ() / 2.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 32.0));
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
for (i1 = 0; i1 < nb_slices; i1++)
{
if (((Standard_Byte**)ds->myData)[i1])
{
Standard_Boolean has_value = Standard_False;
fprintf(f, "%d ", i1); // index of slice
for (i2 = 0; i2 < 32; i2++)
{
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)ds->myData)[i1])[i2];
if (value)
{
has_value = Standard_True;
fprintf(f, "%d %d\n", i2, value);
}
}
if (!has_value)
{
fprintf(f, "0 0\n");
}
}
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Writer::WriteFloatAsciiVoxels(const TCollection_ExtendedString& file) const
{
Voxel_FloatDS* ds = (Voxel_FloatDS*) myFloatVoxels;
if (!ds->myData)
return Standard_False;
// Open file for writing
FILE* f = OSD_OpenFile(file, "w+");
if (!f)
return Standard_False;
// Header: file format, type of voxels
fprintf(f, VOXELS);
fprintf(f, " ");
fprintf(f, ASCII);
fprintf(f, " ");
fprintf(f, FLOAT);
fprintf(f, "\n");
// Location, size, number of splits
fprintf(f, "%g %g %g\n", ds->GetX(), ds->GetY(), ds->GetZ());
fprintf(f, "%g %g %g\n", ds->GetXLen(), ds->GetYLen(), ds->GetZLen());
fprintf(f, "%d %d %d\n", ds->GetNbX(), ds->GetNbY(), ds->GetNbZ());
// Data
// Copied from Voxel_FloatDS.cxx:
Standard_Integer nb_floats = ds->GetNbX() * ds->GetNbY() * ds->GetNbZ();
Standard_Integer nb_slices = RealToInt(ceil(nb_floats / 32.0)); // 32 values in 1 slice
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
for (i1 = 0; i1 < nb_slices; i1++)
{
if (((Standard_ShortReal**)ds->myData)[i1])
{
Standard_Boolean has_value = Standard_False;
fprintf(f, "%d ", i1); // index of slice
for (i2 = 0; i2 < 32; i2++)
{
Standard_ShortReal value = ((Standard_ShortReal*)((Standard_ShortReal**)ds->myData)[i1])[i2];
if (value)
{
has_value = Standard_True;
fprintf(f, "%d %g\n", i2, value);
}
}
if (!has_value)
{
fprintf(f, "0 0\n");
}
}
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Writer::WriteBoolBinaryVoxels(const TCollection_ExtendedString& file) const
{
Voxel_BoolDS* ds = (Voxel_BoolDS*) myBoolVoxels;
if (!ds->myData)
return Standard_False;
// Open file for writing
FILE* f = OSD_OpenFile(file, "wb");
if (!f)
return Standard_False;
// Header: file format, type of voxels
fprintf(f, VOXELS);
fprintf(f, " ");
fprintf(f, BINARY);
fprintf(f, " ");
fprintf(f, BOOL);
fprintf(f, "\n");
// Location, size, number of splits
fwrite(&(ds->myX), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myY), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myZ), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myXLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myYLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myZLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myNbX), sizeof(Standard_Integer), 1, f);
fwrite(&(ds->myNbY), sizeof(Standard_Integer), 1, f);
fwrite(&(ds->myNbZ), sizeof(Standard_Integer), 1, f);
// Data
// Copied from Voxel_BoolDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(ds->GetNbX() * ds->GetNbY() * ds->GetNbZ() / 8.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 8.0));
// myData[0 .. nb_slices - 1][0 .. 7]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
for (i1 = 0; i1 < nb_slices; i1++)
{
if (((Standard_Byte**)ds->myData)[i1])
{
for (i2 = 0; i2 < 8; i2++)
{
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)ds->myData)[i1])[i2];
if (value)
{
fwrite(&i1, sizeof(Standard_Integer), 1, f);
fwrite(&i2, sizeof(Standard_Integer), 1, f);
fwrite(&value, sizeof(Standard_Byte), 1, f);
}
}
}
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Writer::WriteColorBinaryVoxels(const TCollection_ExtendedString& file) const
{
Voxel_ColorDS* ds = (Voxel_ColorDS*) myColorVoxels;
if (!ds->myData)
return Standard_False;
// Open file for writing
FILE* f = OSD_OpenFile(file, "wb");
if (!f)
return Standard_False;
// Header: file format, type of voxels
fprintf(f, VOXELS);
fprintf(f, " ");
fprintf(f, BINARY);
fprintf(f, " ");
fprintf(f, COLOR);
fprintf(f, "\n");
// Location, size, number of splits
fwrite(&(ds->myX), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myY), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myZ), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myXLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myYLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myZLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myNbX), sizeof(Standard_Integer), 1, f);
fwrite(&(ds->myNbY), sizeof(Standard_Integer), 1, f);
fwrite(&(ds->myNbZ), sizeof(Standard_Integer), 1, f);
// Data
// Copied from Voxel_ColorDS.cxx:
Standard_Integer nb_bytes = RealToInt(ceil(ds->myNbX * ds->myNbY * ds->myNbZ / 2.0));
Standard_Integer nb_slices = RealToInt(ceil(nb_bytes / 32.0));
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
for (i1 = 0; i1 < nb_slices; i1++)
{
if (((Standard_Byte**)ds->myData)[i1])
{
for (i2 = 0; i2 < 32; i2++)
{
Standard_Byte value = ((Standard_Byte*)((Standard_Byte**)ds->myData)[i1])[i2];
if (value)
{
fwrite(&i1, sizeof(Standard_Integer), 1, f);
fwrite(&i2, sizeof(Standard_Integer), 1, f);
fwrite(&value, sizeof(Standard_Byte), 1, f);
}
}
}
}
}
fclose(f);
return Standard_True;
}
Standard_Boolean Voxel_Writer::WriteFloatBinaryVoxels(const TCollection_ExtendedString& file) const
{
Voxel_FloatDS* ds = (Voxel_FloatDS*) myFloatVoxels;
if (!ds->myData)
return Standard_False;
// Open file for writing
FILE* f = OSD_OpenFile(file, "wb");
if (!f)
return Standard_False;
// Header: file format, type of voxels
fprintf(f, VOXELS);
fprintf(f, " ");
fprintf(f, BINARY);
fprintf(f, " ");
fprintf(f, FLOAT);
fprintf(f, "\n");
// Location, size, number of splits
fwrite(&(ds->myX), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myY), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myZ), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myXLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myYLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myZLen), sizeof(Standard_Real), 1, f);
fwrite(&(ds->myNbX), sizeof(Standard_Integer), 1, f);
fwrite(&(ds->myNbY), sizeof(Standard_Integer), 1, f);
fwrite(&(ds->myNbZ), sizeof(Standard_Integer), 1, f);
// Data
// Copied from Voxel_FloatDS.cxx:
Standard_Integer nb_floats = ds->myNbX * ds->myNbY * ds->myNbZ;
Standard_Integer nb_slices = RealToInt(ceil(nb_floats / 32.0)); // 32 values in 1 slice
// myData[0 .. nb_slices - 1][0 .. 31]
if (nb_slices)
{
Standard_Integer i1 = 0, i2 = 0;
Standard_Real small = Precision::SquareConfusion();
for (i1 = 0; i1 < nb_slices; i1++)
{
if (((Standard_ShortReal**)ds->myData)[i1])
{
for (i2 = 0; i2 < 32; i2++)
{
Standard_ShortReal value = ((Standard_ShortReal*)((Standard_ShortReal**)ds->myData)[i1])[i2];
if (fabs(value) > small)
{
fwrite(&i1, sizeof(Standard_Integer), 1, f);
fwrite(&i2, sizeof(Standard_Integer), 1, f);
fwrite(&value, sizeof(Standard_ShortReal), 1, f);
}
}
}
}
}
fclose(f);
return Standard_True;
}

106
src/Voxel/Voxel_Writer.hxx
View File

@ -1,106 +0,0 @@
// Created on: 2008-08-28
// Created by: Vladislav ROMASHKO
// Copyright (c) 2008-2014 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.
#ifndef _Voxel_Writer_HeaderFile
#define _Voxel_Writer_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Voxel_VoxelFileFormat.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
class Voxel_BoolDS;
class Voxel_ColorDS;
class Voxel_FloatDS;
class TCollection_ExtendedString;
//! Writes a cube of voxels on disk.
class Voxel_Writer
{
public:
DEFINE_STANDARD_ALLOC
//! An empty constructor.
Standard_EXPORT Voxel_Writer();
//! Defines the file format for voxels.
//! ASCII - slow and occupies more space on disk.
//! BINARY - fast and occupies less space on disk.
Standard_EXPORT void SetFormat (const Voxel_VoxelFileFormat format);
//! Defines the voxels (1bit).
Standard_EXPORT void SetVoxels (const Voxel_BoolDS& voxels);
//! Defines the voxels (4bit).
Standard_EXPORT void SetVoxels (const Voxel_ColorDS& voxels);
//! Defines the voxels (4bytes).
Standard_EXPORT void SetVoxels (const Voxel_FloatDS& voxels);
//! Writes the voxels on disk
//! using the defined format and file name.
Standard_EXPORT Standard_Boolean Write (const TCollection_ExtendedString& file) const;
protected:
private:
//! Writes 1bit voxels on disk in ASCII format.
Standard_EXPORT Standard_Boolean WriteBoolAsciiVoxels (const TCollection_ExtendedString& file) const;
//! Writes 4bit voxels on disk in ASCII format.
Standard_EXPORT Standard_Boolean WriteColorAsciiVoxels (const TCollection_ExtendedString& file) const;
//! Writes 4bytes voxels on disk in ASCII format.
Standard_EXPORT Standard_Boolean WriteFloatAsciiVoxels (const TCollection_ExtendedString& file) const;
//! Writes 1bit voxels on disk in BINARY format.
Standard_EXPORT Standard_Boolean WriteBoolBinaryVoxels (const TCollection_ExtendedString& file) const;
//! Writes 4bit voxels on disk in BINARY format.
Standard_EXPORT Standard_Boolean WriteColorBinaryVoxels (const TCollection_ExtendedString& file) const;
//! Writes 4bytes voxels on disk in BINARY format.
Standard_EXPORT Standard_Boolean WriteFloatBinaryVoxels (const TCollection_ExtendedString& file) const;
Voxel_VoxelFileFormat myFormat;
Standard_Address myBoolVoxels;
Standard_Address myColorVoxels;
Standard_Address myFloatVoxels;
};
#endif // _Voxel_Writer_HeaderFile

73
tests/bugs/vis/bug19820
View File

@ -1,73 +0,0 @@
puts "============"
puts "OCC19820"
puts "============"
puts ""
#######################################################################
# 3D discrete topology (voxels)
#######################################################################
set BugNumber OCC19820
set status 0
puts "1. voxelboolds ..."
if [catch {voxelboolds}] {
set status 1
}
puts "2. voxelcolords ..."
if [catch {voxelcolords}] {
set status 1
}
puts "3. voxelfloatds ..."
if [catch {voxelfloatds}] {
set status 1
}
puts "4. voxeloctboolds ..."
if [catch {voxeloctboolds}] {
set status 1
}
puts "5. voxelroctboolds ..."
if [catch {voxelroctboolds}] {
set status 1
}
puts "6. voxelfuseboolds ..."
if [catch {voxelfuseboolds}] {
set status 1
}
puts "7. voxelfusecolords ..."
if [catch {voxelfusecolords}] {
set status 1
}
puts "8. voxelfusefloatds ..."
if [catch {voxelfusefloatds}] {
set status 1
}
puts "9. voxelcutboolds ..."
if [catch {voxelcutboolds}] {
set status 1
}
puts "10. voxelcutcolords ..."
if [catch {voxelcutcolords}] {
set status 1
}
puts "11. voxelcutfloatds ..."
if [catch {voxelcutfloatds}] {
set status 1
}
if { ${status} != 0 } {
puts "Faulty ${BugNumber}"
} else {
puts "OK ${BugNumber}"
}

9
tests/bugs/vis/bug24019
View File

@ -1,9 +0,0 @@
puts "==========="
puts "OCC24019"
puts "==========="
##########################################
# Voxel_FastConverter: filleng problem
##########################################
OCC24019 [locate_data_file bug24019_boxes5.brep]

9
tests/bugs/vis/bug24051
View File

@ -1,9 +0,0 @@
puts "============"
puts "OCC24051"
puts "============"
puts ""
#######################################################################################
# Voxel_FastConverter::Convert / ConvertUsingSAT - problems in multithreaded scenario
#######################################################################################
OCC24051

1
tests/v3d/grids.list
View File

@ -9,7 +9,6 @@
009 vertex_wire
010 wire
011 wire_solid
012 voxel
013 glsl
014 raytrace
015 materials

1
tests/v3d/voxel/A1
View File

@ -1 +0,0 @@
voxelboolds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A2
View File

@ -1 +0,0 @@
voxelcolords -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A3
View File

@ -1 +0,0 @@
voxelfloatds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A4
View File

@ -1 +0,0 @@
voxeloctboolds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A5
View File

@ -1 +0,0 @@
voxelroctboolds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A6
View File

@ -1 +0,0 @@
voxelfuseboolds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A7
View File

@ -1 +0,0 @@
voxelfusecolords -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A8
View File

@ -1 +0,0 @@
voxelfusefloatds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/A9
View File

@ -1 +0,0 @@
voxelcutboolds -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/B1
View File

@ -1 +0,0 @@
voxelcutcolords -5 -5 -5 10 10 10 10 10 10

1
tests/v3d/voxel/B2
View File

@ -1 +0,0 @@
voxelcutfloatds -5 -5 -5 10 10 10 10 10 10

9
tests/v3d/voxel/B3
View File

@ -1,9 +0,0 @@
psphere s 100.0
voxelbooldsconvert s 100 100 100 1.0 0 1 0 0
voxelbooldsconvert s 100 100 100 1.0 1 1 0 0
voxelbooldsconvert s 100 100 100 1.0 0 1 1 0
voxelbooldsconvert s 100 100 100 1.0 1 1 1 0
voxelbooldsconvert s 100 100 100 1.0 0 2 1 0
voxelbooldsconvert s 100 100 100 1.0 1 2 1 0
voxelbooldsconvert s 100 100 100 1.0 0 2 1 1
voxelbooldsconvert s 100 100 100 1.0 1 2 1 2

1
tests/v3d/voxel/begin
View File

@ -1 +0,0 @@
vinit View1