--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+\f
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+\f
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+\f
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : HEXABLOCKPLUGIN_version.h
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Module : SALOME
+//
+#if !defined(__HEXABLOCKPLUGIN_VERSION_H__)
+#define __HEXABLOCKPLUGIN_VERSION_H__
+
+/*
+ HEXABLOCKPLUGIN_VERSION is (major << 16) + (minor << 8) + patch.
+*/
+
+#define HEXABLOCKPLUGIN_VERSION_STR "@VERSION@"
+#define HEXABLOCKPLUGIN_VERSION @XVERSION@
+#define HEXABLOCKPLUGIN_DEVELOPMENT @VERSION_DEV@
+
+#endif // __HEXABLOCKPLUGIN_VERSION_H__
--- /dev/null
+SALOME2 : HEXABLOCKPLUGIN module (SMESH plugin)
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# $Header:
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+if HEXABLOCKPLUGIN_ENABLE_GUI
+ ACLOCAL_AMFLAGS = -I adm_local/unix/config_files \
+ -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+ -I ${GUI_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files
+else !HEXABLOCKPLUGIN_ENABLE_GUI
+ ACLOCAL_AMFLAGS = -I adm_local/unix/config_files \
+ -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+ -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files
+endif
+
+SUBDIRS = idl adm_local resources src bin
+
+DIST_SUBDIRS = idl adm_local resources src bin
+
+DISTCLEANFILES = a.out aclocal.m4 configure local-install.sh
+
+salomeinclude_DATA = HEXABLOCKPLUGIN_version.h
+
+EXTRA_DIST += \
+ build_configure \
+ clean_configure
+
+dist-hook:
+ rm -rf `find $(distdir) -name CVS`
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+SUBDIRS = unix
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+SUBDIRS = config_files
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+dist_admlocalm4_DATA = \
+ check_HEXABLOCKPLUGIN.m4
--- /dev/null
+dnl Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+dnl
+dnl This library is free software; you can redistribute it and/or
+dnl modify it under the terms of the GNU Lesser General Public
+dnl License as published by the Free Software Foundation; either
+dnl version 2.1 of the License.
+dnl
+dnl This library is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+dnl Lesser General Public License for more details.
+dnl
+dnl You should have received a copy of the GNU Lesser General Public
+dnl License along with this library; if not, write to the Free Software
+dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+dnl
+dnl See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+dnl
+
+# Check availability of HEXABLOCKPLUGIN binary distribution
+#
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+#------------------------------------------------------------
+
+AC_DEFUN([CHECK_HEXABLOCKPLUGIN],[
+
+HEXABLOCKPLUGIN_LDFLAGS=""
+HEXABLOCKPLUGIN_CXXFLAGS=""
+
+AC_CHECKING(for GHS3dPlugin)
+
+HEXABLOCKPLUGIN_ok=no
+
+AC_ARG_WITH(ghs,
+ --with-HEXABLOCKPlugin=DIR root directory path of HEXABLOCKPLUGIN build or installation,
+ HEXABLOCKPLUGIN_DIR="$withval",HEXABLOCKPLUGIN_DIR="")
+
+if test "x$HEXABLOCKPLUGIN_DIR" = "x" ; then
+
+# no --with-gui-dir option used
+
+ if test "x$HEXABLOCKPLUGIN_ROOT_DIR" != "x" ; then
+
+ # SALOME_ROOT_DIR environment variable defined
+ HEXABLOCKPLUGIN_DIR=$HEXABLOCKPLUGIN_ROOT_DIR
+
+ else
+
+ # search Salome binaries in PATH variable
+ AC_PATH_PROG(TEMP, libHexaBlockEngine.so)
+ if test "x$TEMP" != "x" ; then
+ HEXABLOCKPLUGIN_DIR=`dirname $TEMP`
+ fi
+
+ fi
+
+fi
+
+if test -f ${HEXABLOCKPLUGIN_DIR}/lib/salome/libHexaBlockEngine.so ; then
+ HEXABLOCKPLUGIN_ok=yes
+ AC_MSG_RESULT(Using HEXABLOCKPLUGIN module distribution in ${HEXABLOCKPLUGIN_DIR})
+
+ if test "x$HEXABLOCKPLUGIN_ROOT_DIR" == "x" ; then
+ HEXABLOCKPLUGIN_ROOT_DIR=${HEXABLOCKPLUGIN_DIR}
+ fi
+ HEXABLOCKPLUGIN_CXXFLAGS+=-I${HEXABLOCKPLUGIN_ROOT_DIR}/include/salome
+ HEXABLOCKPLUGIN_LDFLAGS+=-L${HEXABLOCKPLUGIN_ROOT_DIR}/lib${LIB_LOCATION_SUFFIX}/salome
+ AC_SUBST(HEXABLOCKPLUGIN_ROOT_DIR)
+ AC_SUBST(HEXABLOCKPLUGIN_LDFLAGS)
+ AC_SUBST(HEXABLOCKPLUGIN_CXXFLAGS)
+else
+ AC_MSG_WARN("Cannot find compiled HEXABLOCKPLUGIN module distribution")
+fi
+
+AC_MSG_RESULT(for HEXABLOCKPLUGIN: $HEXABLOCKPLUGIN_ok)
+
+])dnl
+
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# ============================================================
+# The following is to avoid PACKAGE_... env variable
+# redefinition compilation warnings
+# ============================================================
+#
+AM_CXXFLAGS = @KERNEL_CXXFLAGS@ -include SALOMEconfig.h
+AM_CPPFLAGS = @KERNEL_CXXFLAGS@ -include SALOMEconfig.h
+
+# ============================================================
+# This file defines the common definitions used in several
+# Makefile. This file must be included, if needed, by the file
+# Makefile.am.
+# ============================================================
+# Standard directory for installation
+#
+salomeincludedir = $(includedir)/salome
+libdir = $(prefix)/lib@LIB_LOCATION_SUFFIX@/salome
+bindir = $(prefix)/bin/salome
+salomescriptdir = $(bindir)
+salomepythondir = $(pythondir)/salome
+salomepyexecdir = $(pyexecdir)/salome
+
+# Directory for installing idl files
+salomeidldir = $(prefix)/idl/salome
+
+# Directory for installing resource files
+salomeresdir = $(prefix)/share/salome/resources/@MODULE_NAME@
+
+# Directories for installing admin files
+admlocaldir = $(prefix)/adm_local
+admlocalunixdir = $(admlocaldir)/unix
+admlocalm4dir = $(admlocaldir)/unix/config_files
+
+# Shared modules installation directory
+sharedpkgpythondir = $(salomepythondir)/shared_modules
+
+# Documentation directory
+docdir = $(datadir)/doc/salome
+
+# common rules
+
+# meta object implementation files generation (moc)
+%_moc.cxx: %.h
+ $(MOC) $< -o $@
+
+# translation (*.qm) files generation (lrelease)
+%.qm: %.ts
+ $(LRELEASE) $< -qm $@
+
+# resource files generation (qrcc)
+qrc_%.cxx: %.qrc
+ $(QRCC) $< -o $@ -name $(*F)
+
+# qt forms files generation (uic)
+ui_%.h: %.ui
+ $(UIC) -o $@ $<
+
+# extra distributed files
+EXTRA_DIST = $(MOC_FILES:%_moc.cxx=%.h) $(QRC_FILES:qrc_%.cxx=%.qrc) \
+ $(UIC_FILES:ui_%.h=%.ui) $(nodist_salomeres_DATA:%.qm=%.ts)
+
+# customize clean operation
+mostlyclean-local:
+ rm -f @builddir@/*_moc.cxx
+ rm -f @builddir@/*.qm
+ rm -f @builddir@/ui_*.h
+ rm -f @builddir@/qrc_*.cxx
+
+# tests
+tests: unittest
+
+unittest: $(UNIT_TEST_PROG)
+ @if test "x$(UNIT_TEST_PROG)" != "x"; then \
+ $(UNIT_TEST_PROG); \
+ fi;
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Module : HEXABLOCKPLUGIN
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# non-distributed files
+nodist_salomescript_DATA = VERSION
+
+# distributed files
+dist_salomescript_SCRIPTS =
--- /dev/null
+[SALOME HEXABLOCKPLUGIN] : @VERSION@
+[DEVELOPMENT] : @VERSION_DEV@
+[DESCRIPTION] : HEXABLOCK meshing plug-in for SALOME Mesh module
--- /dev/null
+#!/bin/bash
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# Tool for updating list of .in file for the SALOME project
+# and regenerating configure script
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+# $Header$
+#
+ORIG_DIR=`pwd`
+CONF_DIR=`echo $0 | sed -e "s,[^/]*$,,;s,/$,,;s,^$,.,"`
+
+########################################################################
+# Test if the KERNEL_ROOT_DIR is set correctly
+
+if test ! -d "${KERNEL_ROOT_DIR}"; then
+ echo "failed : KERNEL_ROOT_DIR variable is not correct !"
+ exit
+fi
+
+########################################################################
+# Test if the GEOM_ROOT_DIR is set correctly
+
+if test ! -d "${GEOM_ROOT_DIR}"; then
+ echo "failed : GEOM_ROOT_DIR variable is not correct !"
+ exit
+fi
+
+########################################################################
+# Test if the HEXABLOCK_ROOT_DIR is set correctly
+
+if test ! -d "${HEXABLOCK_ROOT_DIR}"; then
+ echo "failed : HEXABLOCK_ROOT_DIR variable is not correct !"
+ exit
+fi
+
+########################################################################
+# Test if the MED_ROOT_DIR is set correctly
+
+if test ! -d "${MED_ROOT_DIR}"; then
+ echo "failed : MED_ROOT_DIR variable is not correct !"
+ exit
+fi
+
+########################################################################
+# Test if the SMESH_ROOT_DIR is set correctly
+
+if test ! -d "${SMESH_ROOT_DIR}"; then
+ echo "failed : SMESH_ROOT_DIR variable is not correct !"
+ exit
+fi
+
+cd ${CONF_DIR}
+ABS_CONF_DIR=`pwd`
+
+#######################################################################
+
+# ____________________________________________________________________
+# aclocal creates the aclocal.m4 file from the standard macro and the
+# custom macro embedded in the directory adm_local/unix/config_files
+# and KERNEL config_files directory.
+# output:
+# aclocal.m4
+# autom4te.cache (directory)
+echo "======================================================= aclocal"
+
+if test -d "${GUI_ROOT_DIR}"; then
+ aclocal -I adm_local/unix/config_files \
+ -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+ -I ${GUI_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files || exit 1
+else
+ aclocal -I adm_local/unix/config_files \
+ -I ${KERNEL_ROOT_DIR}/salome_adm/unix/config_files \
+ -I ${MED_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${GEOM_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${HEXABLOCK_ROOT_DIR}/adm_local/unix/config_files \
+ -I ${SMESH_ROOT_DIR}/adm_local/unix/config_files || exit 1
+fi
+
+# ____________________________________________________________________
+# libtoolize creates some configuration files (ltmain.sh,
+# config.guess and config.sub). It only depends on the libtool
+# version. The files are created in the directory specified with the
+# AC_CONFIG_AUX_DIR(<mydir>) tag (see configure.ac).
+# output:
+# adm_local/unix/config_files/config.guess
+# adm_local/unix/config_files/config.sub
+# adm_local/unix/config_files/ltmain.sh
+echo "==================================================== libtoolize"
+
+libtoolize --force --copy --automake || exit 1
+
+# ____________________________________________________________________
+# autoconf creates the configure script from the file configure.ac (or
+# configure.in if configure.ac doesn't exist)
+# output:
+# configure
+echo "====================================================== autoconf"
+
+autoconf
+
+# ____________________________________________________________________
+# automake creates some scripts used in building process
+# (install-sh, missing, ...). It only depends on the automake
+# version. The files are created in the directory specified with the
+# AC_CONFIG_AUX_DIR(<mydir>) tag (see configure.ac). This step also
+# creates the Makefile.in files from the Makefile.am files.
+# output:
+# adm_local/unix/config_files/compile
+# adm_local/unix/config_files/depcomp
+# adm_local/unix/config_files/install-sh
+# adm_local/unix/config_files/missing
+# adm_local/unix/config_files/py-compile
+# Makefile.in (from Makefile.am)
+echo "====================================================== automake"
+
+automake --copy --gnu --add-missing
--- /dev/null
+#!/bin/sh
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+rm -rf autom4te.cache aclocal.m4 configure make_config
+find . -name "*~" -print -exec rm {} \;
+find . -name "*.pyc" -print -exec rm {} \;
+find . -name Makefile.in | xargs rm -f
+( cd adm_local/unix/config_files && rm -f config.* depcomp install-sh l*.m4 ltmain.sh missing py-compile )
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# PLEASE DO NOT MODIFY configure.in FILE
+# ALL CHANGES WILL BE DISCARDED BY THE NEXT
+# build_configure COMMAND
+# CHANGES MUST BE MADE IN configure.in.base FILE
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+# Modified by : Patrick GOLDBRONN (CEA)
+# Modified by : Marc Tajchman (CEA)
+# Created from configure.in.base
+#
+AC_INIT([Salome2 Project HEXABLOCKPLUGIN module],[6.5.0], [webmaster.salome@opencascade.com], [SalomeHEXABLOCKPLUGIN])
+AC_CONFIG_AUX_DIR(adm_local/unix/config_files)
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+AM_INIT_AUTOMAKE([-Wno-portability])
+
+XVERSION=`echo $VERSION | awk -F. '{printf("0x%02x%02x%02x",$1,$2,$3)}'`
+AC_SUBST(XVERSION)
+VERSION_DEV=0
+AC_SUBST(VERSION_DEV)
+
+# set up MODULE_NAME variable for dynamic construction of directories (resources, etc.)
+MODULE_NAME=HEXABLOCKplugin
+AC_SUBST(MODULE_NAME)
+
+dnl
+dnl Initialize source and build root directories
+dnl
+
+ROOT_BUILDDIR=`pwd`
+ROOT_SRCDIR=`echo $0 | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"`
+cd $ROOT_SRCDIR
+ROOT_SRCDIR=`pwd`
+cd $ROOT_BUILDDIR
+
+AC_SUBST(ROOT_SRCDIR)
+AC_SUBST(ROOT_BUILDDIR)
+
+echo
+echo Source root directory : $ROOT_SRCDIR
+echo Build root directory : $ROOT_BUILDDIR
+echo
+echo
+
+AC_CHECK_PROG(SHELL,sh)
+AC_SUBST(SHELL)
+
+if test -z "$AR"; then
+ AC_CHECK_PROGS(AR,ar xar,:,$PATH)
+fi
+AC_SUBST(AR)
+
+dnl Export the AR macro so that it will be placed in the libtool file
+dnl correctly.
+export AR
+
+echo
+echo ---------------------------------------------
+echo testing make
+echo ---------------------------------------------
+echo
+
+AC_PROG_MAKE_SET
+AC_PROG_INSTALL
+AC_LOCAL_INSTALL
+dnl
+dnl libtool macro check for CC, LD, NM, LN_S, RANLIB, STRIP + pour les librairies dynamiques !
+
+AC_ENABLE_DEBUG(yes)
+AC_DISABLE_PRODUCTION
+
+echo ---------------------------------------------
+echo testing libtool
+echo ---------------------------------------------
+
+dnl first, we set static to no!
+dnl if we want it, use --enable-static
+AC_ENABLE_STATIC(no)
+
+AC_LIBTOOL_DLOPEN
+AC_PROG_LIBTOOL
+
+dnl Fix up the INSTALL macro if it s a relative path. We want the
+dnl full-path to the binary instead.
+case "$INSTALL" in
+ *install-sh*)
+ INSTALL="${KERNEL_ROOT_DIR}/adm_local/unix/config_files/install-sh -c"
+ ;;
+esac
+
+echo
+echo ---------------------------------------------
+echo testing C/C++
+echo ---------------------------------------------
+echo
+
+cc_ok=no
+dnl inutil car libtool
+dnl AC_PROG_CC
+AC_PROG_CXX
+AC_CXX_WARNINGS
+AC_CXX_TEMPLATE_OPTIONS
+AC_DEPEND_FLAG
+# AC_CC_WARNINGS([ansi])
+cc_ok=yes
+
+dnl Library libdl :
+AC_CHECK_LIB(dl,dlopen)
+
+dnl Library librt : for alpha/osf
+AC_CHECK_LIB(rt,nanosleep)
+
+dnl add library libm :
+AC_CHECK_LIB(m,ceil)
+
+dnl
+dnl Well we use sstream which is not in gcc pre-2.95.3
+dnl We must test if it exists. If not, add it in include !
+dnl
+
+AC_CXX_HAVE_SSTREAM
+
+dnl
+dnl ---------------------------------------------
+dnl testing MPICH
+dnl ---------------------------------------------
+dnl
+
+dnl CHECK_MPICH
+
+echo
+echo ---------------------------------------------
+echo testing MPI
+echo ---------------------------------------------
+echo
+
+CHECK_MPI
+
+echo
+echo ---------------------------------------------
+echo testing LEX \& YACC
+echo ---------------------------------------------
+echo
+
+lex_yacc_ok=no
+AC_PROG_YACC
+AC_PROG_LEX
+lex_yacc_ok=yes
+
+echo
+echo ---------------------------------------------
+echo testing python
+echo ---------------------------------------------
+echo
+
+CHECK_PYTHON
+
+AM_PATH_PYTHON(2.3)
+
+dnl echo
+dnl echo ---------------------------------------------
+dnl echo testing java
+dnl echo ---------------------------------------------
+dnl echo
+
+dnl CHECK_JAVA
+
+echo
+echo ---------------------------------------------
+echo testing swig
+echo ---------------------------------------------
+echo
+
+CHECK_SWIG
+
+echo
+echo ---------------------------------------------
+echo testing threads
+echo ---------------------------------------------
+echo
+
+ENABLE_PTHREADS
+
+echo
+echo ---------------------------------------------
+echo testing omniORB
+echo ---------------------------------------------
+echo
+
+CHECK_OMNIORB
+
+dnl echo
+dnl echo ---------------------------------------------
+dnl echo testing mico
+dnl echo ---------------------------------------------
+dnl echo
+
+dnl CHECK_MICO
+
+echo
+echo ---------------------------------------------
+echo default ORB : omniORB
+echo ---------------------------------------------
+echo
+
+DEFAULT_ORB=omniORB
+CHECK_CORBA
+
+AC_SUBST_FILE(CORBA)
+corba=make_$ORB
+CORBA=adm_local/unix/$corba
+
+echo
+echo ---------------------------------------------
+echo Testing GUI
+echo ---------------------------------------------
+echo
+
+CHECK_GUI_MODULE
+
+gui_ok=no
+if test "${SalomeGUI_need}" != "no" -a "${FullGUI_ok}" = "yes" ; then
+ gui_ok=yes
+fi
+
+AM_CONDITIONAL(HEXABLOCKPLUGIN_ENABLE_GUI, [test "${gui_ok}" = "yes"])
+
+if test "${SalomeGUI_need}" == "yes"; then
+ if test "${FullGUI_ok}" != "yes"; then
+ AC_MSG_WARN(For configure HEXABLOCKPLUGIN module necessary full GUI!)
+ fi
+elif test "${SalomeGUI_need}" == "auto"; then
+ if test "${FullGUI_ok}" != "yes"; then
+ AC_MSG_WARN(Full GUI not found. Build will be done without GUI!)
+ fi
+elif test "${SalomeGUI_need}" == "no"; then
+ echo Build without GUI option has been chosen
+fi
+
+if test "${gui_ok}" = "yes"; then
+
+ echo
+ echo ---------------------------------------------
+ echo testing openGL
+ echo ---------------------------------------------
+ echo
+
+ CHECK_OPENGL
+
+ echo
+ echo ---------------------------------------------
+ echo testing QT
+ echo ---------------------------------------------
+ echo
+
+ CHECK_QT
+
+ echo
+ echo ---------------------------------------------
+ echo testing VTK
+ echo ---------------------------------------------
+ echo
+
+ CHECK_VTK
+fi
+
+echo
+echo ---------------------------------------------
+echo Testing HDF5
+echo ---------------------------------------------
+echo
+
+CHECK_HDF5
+
+echo
+echo ---------------------------------------------
+echo BOOST Library
+echo ---------------------------------------------
+echo
+
+CHECK_BOOST
+
+echo
+echo ---------------------------------------------
+echo Testing OpenCascade
+echo ---------------------------------------------
+echo
+
+CHECK_CAS
+
+echo
+echo ---------------------------------------------
+echo Testing html generators
+echo ---------------------------------------------
+echo
+
+CHECK_HTML_GENERATORS
+
+echo
+echo ---------------------------------------------
+echo Testing Kernel
+echo ---------------------------------------------
+echo
+
+CHECK_KERNEL
+
+echo
+echo ---------------------------------------------
+echo Testing Geom
+echo ---------------------------------------------
+echo
+
+CHECK_GEOM
+
+echo
+echo ---------------------------------------------
+echo Testing Med
+echo ---------------------------------------------
+echo
+
+CHECK_MED
+
+echo
+echo ---------------------------------------------
+echo Testing SMesh
+echo ---------------------------------------------
+echo
+
+CHECK_SMESH
+
+echo
+echo ---------------------------------------------
+echo Testing HEXABLOCK
+echo ---------------------------------------------
+echo
+
+CHECK_HEXABLOCK
+
+echo
+echo ---------------------------------------------
+echo Summary
+echo ---------------------------------------------
+echo
+
+echo Configure
+if test "${gui_ok}" = "yes"; then
+ variables="cc_ok boost_ok threads_ok omniORB_ok occ_ok doxygen_ok OpenGL_ok qt_ok vtk_ok Kernel_ok gui_ok Geom_ok Med_ok SMesh_ok HEXABLOCK_ok"
+elif test "${SalomeGUI_need}" != "no"; then
+ variables="cc_ok boost_ok threads_ok omniORB_ok occ_ok doxygen_ok Kernel_ok gui_ok Geom_ok Med_ok SMesh_ok HEXABLOCK_ok"
+else
+ variables="cc_ok boost_ok threads_ok omniORB_ok occ_ok doxygen_ok Kernel_ok Geom_ok Med_ok SMesh_ok HEXABLOCK_ok"
+fi
+
+for var in $variables
+do
+ printf " %10s : " `echo \$var | sed -e "s,_ok,,"`
+ eval echo \$$var
+done
+
+echo
+echo "Default ORB : $DEFAULT_ORB"
+echo
+
+dnl We don t need to say when we re entering directories if we re using
+dnl GNU make becuase make does it for us.
+if test "X$GMAKE" = "Xyes"; then
+ AC_SUBST(SETX) SETX=":"
+else
+ AC_SUBST(SETX) SETX="set -x"
+fi
+echo
+echo ---------------------------------------------
+echo generating Makefiles and configure files
+echo ---------------------------------------------
+echo
+
+AC_OUTPUT_COMMANDS([ \
+ chmod +x ./bin/*; \
+])
+
+# This list is initiated using autoscan and must be updated manually
+# when adding a new file <filename>.in to manage. When you execute
+# autoscan, the Makefile list is generated in the output file configure.scan.
+# This could be helpfull to update de configuration.
+AC_OUTPUT([ \
+ adm_local/Makefile \
+ adm_local/unix/Makefile \
+ adm_local/unix/config_files/Makefile \
+ bin/VERSION \
+ bin/Makefile \
+ HEXABLOCKPLUGIN_version.h \
+ src/Makefile \
+ src/HEXABLOCKPlugin/Makefile \
+ src/GUI/Makefile \
+ resources/Makefile \
+ idl/Makefile \
+ Makefile \
+])
--- /dev/null
+#------ HEXABLOCKPLUGIN_src ------
+export HEXABLOCKPLUGIN_SRC_DIR=${INST_ROOT}/HEXABLOCKPLUGIN_SRC_6.2.0
+##
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : HEXABLOCK_Algorithm.idl
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// $Header$
+//
+#ifndef _HEXABLOCK_Algorithm_IDL_
+#define _HEXABLOCK_Algorithm_IDL_
+
+#include "SALOME_Exception.idl"
+#include "SMESH_Hypothesis.idl"
+
+#include "Document.idl"
+/*!
+ * HEXABLOCKPlugin: interfaces to HEXABLOCK related hypotheses and algorithms
+ */
+module HEXABLOCKPlugin
+{
+
+ /*!
+ * HEXABLOCKPlugin_HEXABLOCK: interface of "hexaBlock" algorithm
+ */
+ interface HEXABLOCKPlugin_HEXABLOCK : SMESH::SMESH_3D_Algo
+ {
+ };
+
+ /*!
+ * Parameters of "HexaBlock" algorithm
+ */
+ interface HEXABLOCKPlugin_Hypothesis : SMESH::SMESH_Hypothesis
+ {
+ /*!
+ * Define the document to be meshed, mandatory
+ */
+ void SetDocument(in HEXABLOCK_ORB::Document doc);
+ HEXABLOCK_ORB::Document GetDocument();
+
+ /*!
+ * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+ */
+ void SetDimension(in long dim);
+ long GetDimension();
+ };
+};
+
+#endif
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# This Makefile is responsible of generating the client and server
+# implementation of IDL interfaces for both C++ and python usage.
+# The building process of the C++ files is in charge of each source
+# package and then is not manage here.
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+BASEIDL_FILES = HEXABLOCKPlugin_Algorithm.idl
+
+BASEIDL_FILES_PY=$(BASEIDL_FILES:%.idl=%_idl.py)
+
+# This variable defines the files to be installed
+dist_salomeidl_DATA = $(BASEIDL_FILES)
+
+# GUI idl common library
+lib_LTLIBRARIES = libSalomeIDLHEXABLOCKPLUGIN.la
+
+# Sources built from idl files
+nodist_libSalomeIDLHEXABLOCKPLUGIN_la_SOURCES = \
+ HEXABLOCKPlugin_AlgorithmSK.cc \
+ HEXABLOCKPlugin_AlgorithmDynSK.cc
+HEXABLOCKPlugin_AlgorithmDynSK.cc: HEXABLOCKPlugin_AlgorithmSK.cc
+
+# header files must be exported: other modules have to use this library
+nodist_salomeinclude_HEADERS = $(BASEIDL_FILES:%.idl=%.hh)
+
+libSalomeIDLHEXABLOCKPLUGIN_la_CPPFLAGS = \
+ -I$(top_builddir)/idl \
+ $(CORBA_CXXFLAGS) \
+ $(CORBA_INCLUDES) \
+ $(KERNEL_CXXFLAGS) \
+ $(GEOM_CXXFLAGS) \
+ $(HEXABLOCK_CXXFLAGS) \
+ $(SMESH_CXXFLAGS)
+
+libSalomeIDLHEXABLOCKPLUGIN_la_LDFLAGS = -no-undefined -version-info=0:0:0
+libSalomeIDLHEXABLOCKPLUGIN_la_LIBADD = \
+ $(KERNEL_LDFLAGS) -lSalomeIDLKernel \
+ $(GEOM_LDFLAGS) -lSalomeIDLGEOM \
+ $(HEXABLOCK_LDFLAGS) -lSalomeIDLHEXABLOCK \
+ $(SMESH_LDFLAGS) -lSalomeIDLSMESH \
+ @CORBA_LIBS@
+
+# These variables defines the building process of CORBA files
+OMNIORB_IDL = @OMNIORB_IDL@
+OMNIORB_IDLCXXFLAGS = @OMNIORB_IDLCXXFLAGS@
+OMNIORB_IDLPYFLAGS = \
+ @OMNIORB_IDLPYFLAGS@ \
+ -I$(top_builddir)/idl/salome \
+ -I$(KERNEL_ROOT_DIR)/idl/salome \
+ -I$(GEOM_ROOT_DIR)/idl/salome \
+ -I$(HEXABLOCK_ROOT_DIR)/idl/salome \
+ -I$(SMESH_ROOT_DIR)/idl/salome
+
+IDLCXXFLAGS = \
+ -bcxx \
+ @IDLCXXFLAGS@ \
+ -I$(top_builddir)/idl/salome \
+ -I$(KERNEL_ROOT_DIR)/idl/salome \
+ -I$(GEOM_ROOT_DIR)/idl/salome \
+ -I$(HEXABLOCK_ROOT_DIR)/idl/salome \
+ -I$(SMESH_ROOT_DIR)/idl/salome
+IDLPYFLAGS = \
+ @IDLPYFLAGS@ \
+ -I$(KERNEL_ROOT_DIR)/idl/salome \
+ -I$(GEOM_ROOT_DIR)/idl/salome \
+ -I$(HEXABLOCK_ROOT_DIR)/idl/salome \
+ -I$(SMESH_ROOT_DIR)/idl/salome
+
+# potential problem on parallel make on the following - multiple outputs
+SUFFIXES = .idl .hh SK.cc
+.idlSK.cc:
+ $(OMNIORB_IDL) $(IDLCXXFLAGS) $(OMNIORB_IDLCXXFLAGS) $<
+.idl.hh:
+ $(OMNIORB_IDL) $(IDLCXXFLAGS) $(OMNIORB_IDLCXXFLAGS) $<
+
+install-exec-local: $(BASEIDL_FILES:%=$(top_srcdir)/idl/%)
+ $(INSTALL) -d $(DESTDIR)$(salomepythondir)
+ ls $^ | while read file; do \
+ $(OMNIORB_IDL) $(IDLPYFLAGS) -C$(DESTDIR)$(salomepythondir) $$file ; \
+ done
+
+# we want to remove only staff generated for IDL files and nothing more
+uninstall-local:
+ @for modulen in HEXABLOCKPlugin ; do \
+ test -d $(DESTDIR)$(salomepythondir)/$${modulen} && echo "Removing $(DESTDIR)$(salomepythondir)/$${modulen}" && rm -rf $(DESTDIR)$(salomepythondir)/$${modulen} ; \
+ test -d $(DESTDIR)$(salomepythondir)/$${modulen}__POA && echo "Removing $(DESTDIR)$(salomepythondir)/$${modulen}__POA" && rm -rf $(DESTDIR)$(salomepythondir)/$${modulen}__POA ; \
+ done ; \
+ for filen in $(BASEIDL_FILES_PY) ; do \
+ echo "Removing $(DESTDIR)$(salomepythondir)/$${filen}" && rm -f $(DESTDIR)$(salomepythondir)/$${filen}* ; \
+ done
+
+mostlyclean-local:
+ -rm -f *.hh *.cc .depidl
+
+# we use cpp to generate dependencies between idl files.
+# option x c tells the preprocessor to consider idl as a c file.
+# if an idl is modified, all idl dependencies are rebuilt
+
+.depidl: $(BASEIDL_FILES)
+ @echo "" > $@
+ @for dep in $^ dummy; do \
+ if [ $$dep != "dummy" ]; then \
+ echo Building dependencies for $$dep; \
+ $(CPP) $(C_DEPEND_FLAG) -x c -I$(srcdir) -I$(KERNEL_ROOT_DIR)/idl/salome -I$(GEOM_ROOT_DIR)/idl/salome -I$(HEXABLOCK_ROOT_DIR)/idl/salome -I$(SMESH_ROOT_DIR)/idl/salome $$dep 2>/dev/null | \
+ sed 's/\.o/\SK.cc/' >>$@; \
+ fi; \
+ done ;
+
+-include .depidl
--- /dev/null
+<?xml version='1.0' encoding='us-ascii'?>
+<!DOCTYPE meshers PUBLIC "" "desktop.dtd">
+<!--
+ Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http:www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+
+<!-- GUI customization for MESH component -->
+
+<meshers>
+
+<meshers-group name="HEXABLOCK"
+ resources="HEXABLOCKPlugin"
+ server-lib="HEXABLOCKEngine"
+ gui-lib="HEXABLOCKPluginGUI">
+
+ <hypotheses>
+ <hypothesis type="HEXABLOCK_Parameters"
+ label-id="HEXABLOCK_Parameters"
+ icon-id="mesh_hypo_HEXABLOCK.png"
+ dim="3"/>
+ </hypotheses>
+
+ <algorithms>
+ <algorithm type="HEXABLOCK_3D"
+ label-id="Hexahedron (HEXABLOCK)"
+ icon-id="mesh_tree_hypo_HEXABLOCK.png"
+ need-geom="false"
+ hypos="HEXABLOCK_Parameters"
+ dim="3"
+ support-submeshes="false"
+ />
+ </algorithms>
+</meshers-group>
+
+</meshers>
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Date : 2010/11/08
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# $Header$
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+dist_salomeres_DATA = \
+ HEXABLOCKPlugin.xml \
+ SalomeApp.xml
+
+if HEXABLOCKPLUGIN_ENABLE_GUI
+ dist_salomeres_DATA += \
+ mesh_hypo_HEXABLOCK.png \
+ mesh_tree_hypo_HEXABLOCK.png
+endif
--- /dev/null
+<!--
+ Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http:www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+<document>
+ <section name="resources">
+ <parameter name="HEXABLOCKPlugin" value="${HEXABLOCKPLUGIN_ROOT_DIR}/share/salome/resources/HEXABLOCKplugin"/>
+ </section>
+ <section name="SMESH">
+ <!-- Default SMESH module plugins -->
+ <parameter name="plugins" value="HEXABLOCKPlugin"/>
+ </section>
+</document>
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// HEXABLOCKPlugin GUI: GUI for plugged-in mesher HEXABLOCKPlugin
+// File : HEXABLOCKPluginGUI_HypothesisCreator.cxx
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Module : HEXABLOCKPlugin
+// $Header:
+//
+#include "HEXABLOCKPluginGUI_HypothesisCreator.h"
+
+#include <SMESHGUI_Utils.h>
+#include <SMESHGUI_HypothesesUtils.h>
+
+#include <SUIT_Session.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_FileDlg.h>
+#include <SalomeApp_Tools.h>
+#include <SalomeApp_TypeFilter.h>
+
+#include <QComboBox>
+#include <QLabel>
+#include <QFrame>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <QLineEdit>
+#include <QCheckBox>
+#include <QTabWidget>
+#include <QSpinBox>
+#include <QPushButton>
+#include <QFileInfo>
+
+#include <QTableWidget>
+#include <QStandardItemModel>
+#include <QStandardItem>
+#include <QHeaderView>
+#include <QModelIndexList>
+
+#include <stdexcept>
+#include <utilities.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+// tabs
+enum {
+ STD_TAB = 0,
+ ADV_TAB,
+ ENF_VER_TAB
+};
+
+// Enforced vertices array columns
+enum {
+ ENF_VER_X_COLUMN = 0,
+ ENF_VER_Y_COLUMN,
+ ENF_VER_Z_COLUMN,
+ ENF_VER_SIZE_COLUMN,
+ ENF_VER_NB_COLUMNS
+};
+
+// Enforced vertices inputs
+enum {
+ ENF_VER_BTNS = 0,
+ ENF_VER_X_COORD,
+ ENF_VER_Y_COORD,
+ ENF_VER_Z_COORD,
+ ENF_VER_SIZE,
+ ENF_VER_VERTEX_BTN,
+ ENF_VER_SEPARATOR,
+ ENF_VER_REMOVE_BTN,
+};
+
+namespace {
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <sys/sysinfo.h>
+#endif
+
+ int maxAvailableMemory()
+ {
+#ifdef WIN32
+ // See http://msdn.microsoft.com/en-us/library/aa366589.aspx
+ MEMORYSTATUSEX statex;
+ statex.dwLength = sizeof (statex);
+ int err = GlobalMemoryStatusEx (&statex);
+ if (err != 0) {
+ int totMB =
+ statex.ullTotalPhys / 1024 / 1024 +
+ statex.ullTotalPageFile / 1024 / 1024 +
+ statex.ullTotalVirtual / 1024 / 1024;
+ return (int) ( 0.7 * totMB );
+ }
+#else
+ struct sysinfo si;
+ int err = sysinfo( &si );
+ if ( err == 0 ) {
+ int totMB =
+ si.totalram * si.mem_unit / 1024 / 1024 +
+ si.totalswap * si.mem_unit / 1024 / 1024 ;
+ return (int) ( 0.7 * totMB );
+ }
+#endif
+ return 0;
+ }
+}
+
+class QDoubleValidator;
+
+//
+// BEGIN DoubleLineEditDelegate
+//
+
+DoubleLineEditDelegate::DoubleLineEditDelegate(QObject *parent)
+ : QItemDelegate(parent)
+{
+}
+
+QWidget *DoubleLineEditDelegate::createEditor(QWidget *parent,
+ const QStyleOptionViewItem &/* option */,
+ const QModelIndex &/* index */) const
+{
+ QLineEdit *editor = new QLineEdit(parent);
+ editor->setValidator(new QDoubleValidator(parent));
+
+ return editor;
+}
+
+void DoubleLineEditDelegate::setEditorData(QWidget *editor,
+ const QModelIndex &index) const
+{
+ QString value = index.model()->data(index, Qt::EditRole).toString();
+
+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
+ lineEdit->setText(value);
+}
+
+void DoubleLineEditDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
+ const QModelIndex &index) const
+{
+ QLineEdit *lineEdit = static_cast<QLineEdit*>(editor);
+ bool ok;
+ double value = lineEdit->text().toDouble(&ok);
+
+ if (ok) {
+ model->setData(index, value, Qt::EditRole);
+ if(MYDEBUG) MESSAGE("Value " << value << " was set at index(" << index.row() << "," << index.column() << ")");
+ }
+}
+
+void DoubleLineEditDelegate::updateEditorGeometry(QWidget *editor,
+ const QStyleOptionViewItem &option, const QModelIndex &/* index */) const
+{
+ editor->setGeometry(option.rect);
+}
+
+//
+// END DoubleLineEditDelegate
+//
+
+HEXABLOCKPluginGUI_HypothesisCreator::HEXABLOCKPluginGUI_HypothesisCreator( const QString& theHypType )
+: SMESHGUI_GenericHypothesisCreator( theHypType )
+{
+}
+
+HEXABLOCKPluginGUI_HypothesisCreator::~HEXABLOCKPluginGUI_HypothesisCreator()
+{
+}
+
+QFrame* HEXABLOCKPluginGUI_HypothesisCreator::buildFrame()
+{
+ QFrame* fr = new QFrame( 0 );
+ QVBoxLayout* lay = new QVBoxLayout( fr );
+ lay->setMargin( 5 );
+ lay->setSpacing( 0 );
+
+ // tab
+ QTabWidget* tab = new QTabWidget( fr );
+ tab->setTabShape( QTabWidget::Rounded );
+ tab->setTabPosition( QTabWidget::North );
+ lay->addWidget( tab );
+
+ // basic parameters
+ myStdGroup = new QWidget();
+ QGridLayout* aStdLayout = new QGridLayout( myStdGroup );
+ aStdLayout->setSpacing( 6 );
+ aStdLayout->setMargin( 11 );
+
+ int row = 0;
+ myName = 0;
+ if( isCreation() )
+ {
+ aStdLayout->addWidget( new QLabel( tr( "SMESH_NAME" ), myStdGroup ), row, 0, 1, 1 );
+ myName = new QLineEdit( myStdGroup );
+ aStdLayout->addWidget( myName, row++, 1, 1, 1 );
+ }
+
+ myToMeshHolesCheck = new QCheckBox( tr( "HEXABLOCK_TO_MESH_HOLES" ), myStdGroup );
+ aStdLayout->addWidget( myToMeshHolesCheck, row++, 0, 1, 2 );
+
+ aStdLayout->addWidget( new QLabel( tr( "HEXABLOCK_OPTIMIZATIOL_LEVEL" ), myStdGroup ), row, 0 );
+ myOptimizationLevelCombo = new QComboBox( myStdGroup );
+ aStdLayout->addWidget( myOptimizationLevelCombo, row++, 1, 1, 1 );
+
+ QStringList types;
+ types << tr( "LEVEL_NONE" ) << tr( "LEVEL_LIGHT" ) << tr( "LEVEL_MEDIUM" ) << tr( "LEVEL_STANDARDPLUS" ) << tr( "LEVEL_STRONG" );
+ myOptimizationLevelCombo->addItems( types );
+
+ aStdLayout->setRowStretch( row, 5 );
+
+ // advanced parameters
+ myAdvGroup = new QWidget();
+ QGridLayout* anAdvLayout = new QGridLayout( myAdvGroup );
+ anAdvLayout->setSpacing( 6 );
+ anAdvLayout->setMargin( 11 );
+
+ myMaximumMemoryCheck = new QCheckBox( tr( "MAX_MEMORY_SIZE" ), myAdvGroup );
+ myMaximumMemorySpin = new QSpinBox( myAdvGroup );
+ myMaximumMemorySpin->setMinimum( 1 );
+ myMaximumMemorySpin->setMaximum( maxAvailableMemory() );
+ myMaximumMemorySpin->setSingleStep( 10 );
+ QLabel* aMegabyteLabel = new QLabel( tr( "MEGABYTE" ), myAdvGroup );
+
+ myInitialMemoryCheck = new QCheckBox( tr( "INIT_MEMORY_SIZE" ), myAdvGroup );
+ myInitialMemorySpin = new QSpinBox( myAdvGroup );
+ myInitialMemorySpin->setMinimum( 1 );
+ myInitialMemorySpin->setMaximum( maxAvailableMemory() );
+ myInitialMemorySpin->setSingleStep( 10 );
+ QLabel* aMegabyteLabel2 = new QLabel( tr( "MEGABYTE" ), myAdvGroup );
+
+ QLabel* aWorkinDirLabel = new QLabel( tr( "WORKING_DIR" ), myAdvGroup );
+ myWorkingDir = new QLineEdit( myAdvGroup );
+ //myWorkingDir->setReadOnly( true );
+ QPushButton* dirBtn = new QPushButton( tr( "SELECT_DIR" ), myAdvGroup );
+ dirBtn->setSizePolicy( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) );
+
+ myKeepFiles = new QCheckBox( tr( "KEEP_WORKING_FILES" ), myAdvGroup );
+
+ QLabel* aVerboseLevelLabel = new QLabel( tr( "VERBOSE_LEVEL" ), myAdvGroup );
+ myVerboseLevelSpin = new QSpinBox( myAdvGroup );
+ myVerboseLevelSpin->setMinimum( 0 );
+ myVerboseLevelSpin->setMaximum( 10 );
+ myVerboseLevelSpin->setSingleStep( 1 );
+
+ myToCreateNewNodesCheck = new QCheckBox( tr( "TO_ADD_NODES" ), myAdvGroup );
+
+ myRemoveInitialCentralPointCheck = new QCheckBox( tr( "NO_INITIAL_CENTRAL_POINT" ), myAdvGroup );
+
+ myBoundaryRecoveryCheck = new QCheckBox( tr( "RECOVERY_VERSION" ), myAdvGroup );
+
+ myFEMCorrectionCheck = new QCheckBox( tr( "FEM_CORRECTION" ), myAdvGroup );
+
+ QLabel* aTextOptionLabel = new QLabel( tr( "TEXT_OPTION" ), myAdvGroup );
+ myTextOption = new QLineEdit( myAdvGroup );
+
+ anAdvLayout->addWidget( myMaximumMemoryCheck, 0, 0, 1, 1 );
+ anAdvLayout->addWidget( myMaximumMemorySpin, 0, 1, 1, 1 );
+ anAdvLayout->addWidget( aMegabyteLabel, 0, 2, 1, 1 );
+ anAdvLayout->addWidget( myInitialMemoryCheck, 1, 0, 1, 1 );
+ anAdvLayout->addWidget( myInitialMemorySpin, 1, 1, 1, 1 );
+ anAdvLayout->addWidget( aMegabyteLabel2, 1, 2, 1, 1 );
+ anAdvLayout->addWidget( aWorkinDirLabel, 2, 0, 1, 1 );
+ anAdvLayout->addWidget( myWorkingDir, 2, 1, 1, 2 );
+ anAdvLayout->addWidget( dirBtn, 2, 3, 1, 1 );
+ anAdvLayout->addWidget( myKeepFiles, 3, 0, 1, 4 );
+ anAdvLayout->addWidget( aVerboseLevelLabel, 4, 0, 1, 1 );
+ anAdvLayout->addWidget( myVerboseLevelSpin, 4, 1, 1, 1 );
+ anAdvLayout->addWidget( myToCreateNewNodesCheck, 5, 0, 1, 4 );
+ anAdvLayout->addWidget( myRemoveInitialCentralPointCheck, 6, 0, 1, 4 );
+ anAdvLayout->addWidget( myBoundaryRecoveryCheck, 7, 0, 1, 4 );
+ anAdvLayout->addWidget( myFEMCorrectionCheck, 8, 0, 1, 4 );
+ anAdvLayout->addWidget( aTextOptionLabel, 9, 0, 1, 1 );
+ anAdvLayout->addWidget( myTextOption, 9, 1, 1, 2 );
+
+ // Size Maps parameters
+ myEnfGroup = new QWidget();
+ QGridLayout* anSmpLayout = new QGridLayout(myEnfGroup);
+
+ mySmpModel = new QStandardItemModel(0, ENF_VER_NB_COLUMNS);
+ myEnforcedTableView = new QTableView(myEnfGroup);
+ myEnforcedTableView->setModel(mySmpModel);
+ myEnforcedTableView->setSortingEnabled(true);
+ myEnforcedTableView->setItemDelegateForColumn(ENF_VER_SIZE_COLUMN,new DoubleLineEditDelegate(this));
+ anSmpLayout->addWidget(myEnforcedTableView, 1, 0, 9, 1);
+ QStringList enforcedHeaders;
+ enforcedHeaders << tr( "HEXABLOCK_ENF_VER_X_COLUMN" )<< tr( "HEXABLOCK_ENF_VER_Y_COLUMN" ) << tr( "HEXABLOCK_ENF_VER_Z_COLUMN" ) << tr( "HEXABLOCK_ENF_VER_SIZE_COLUMN" );
+ mySmpModel->setHorizontalHeaderLabels(enforcedHeaders);
+ myEnforcedTableView->setAlternatingRowColors(true);
+ myEnforcedTableView->verticalHeader()->hide();
+ myEnforcedTableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+
+ QLabel* myXCoordLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_X_LABEL" ), myEnfGroup );
+ anSmpLayout->addWidget(myXCoordLabel, ENF_VER_X_COORD, 1, 1, 1);
+ myXCoord = new QLineEdit(myEnfGroup);
+ myXCoord->setValidator(new QDoubleValidator(myEnfGroup));
+ anSmpLayout->addWidget(myXCoord, ENF_VER_X_COORD, 2, 1, 1);
+ QLabel* myYCoordLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_Y_LABEL" ), myEnfGroup );
+ anSmpLayout->addWidget(myYCoordLabel, ENF_VER_Y_COORD, 1, 1, 1);
+ myYCoord = new QLineEdit(myEnfGroup);
+ myYCoord->setValidator(new QDoubleValidator(myEnfGroup));
+ anSmpLayout->addWidget(myYCoord, ENF_VER_Y_COORD, 2, 1, 1);
+ QLabel* myZCoordLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_Z_LABEL" ), myEnfGroup );
+ anSmpLayout->addWidget(myZCoordLabel, ENF_VER_Z_COORD, 1, 1, 1);
+ myZCoord = new QLineEdit(myEnfGroup);
+ myZCoord->setValidator(new QDoubleValidator(myEnfGroup));
+ anSmpLayout->addWidget(myZCoord, ENF_VER_Z_COORD, 2, 1, 1);
+ QLabel* mySizeLabel = new QLabel( tr( "HEXABLOCK_ENF_VER_SIZE_LABEL" ), myEnfGroup );
+ anSmpLayout->addWidget(mySizeLabel, ENF_VER_SIZE, 1, 1, 1);
+ mySizeValue = new QLineEdit(myEnfGroup);
+ mySizeValue->setValidator(new QDoubleValidator(myEnfGroup));
+ anSmpLayout->addWidget(mySizeValue, ENF_VER_SIZE, 2, 1, 1);
+
+ addVertexButton = new QPushButton(tr("HEXABLOCK_ENF_VER_VERTEX"),myEnfGroup);
+ anSmpLayout->addWidget(addVertexButton, ENF_VER_VERTEX_BTN, 1, 1, 2);
+ addVertexButton->setEnabled(false);
+
+ QFrame *line = new QFrame(myEnfGroup);
+ line->setFrameShape(QFrame::HLine);
+ line->setFrameShadow(QFrame::Sunken);
+ anSmpLayout->addWidget(line, ENF_VER_SEPARATOR, 1, 1, 2);
+
+ removeVertexButton = new QPushButton(tr("HEXABLOCK_ENF_VER_REMOVE"),myEnfGroup);
+ anSmpLayout->addWidget(removeVertexButton, ENF_VER_REMOVE_BTN, 1, 1, 2);
+
+ // add tabs
+ tab->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
+ tab->insertTab( ADV_TAB, myAdvGroup, tr( "HEXABLOCK_ADV_ARGS" ) );
+ tab->insertTab( ENF_VER_TAB, myEnfGroup, tr( "HEXABLOCK_ENFORCED_VERTICES" ) );
+ tab->setCurrentIndex( STD_TAB );
+
+ // connections
+ connect( myMaximumMemoryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ connect( myInitialMemoryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ connect( myBoundaryRecoveryCheck, SIGNAL( toggled( bool ) ), this, SLOT( updateWidgets() ) );
+ connect( dirBtn, SIGNAL( clicked() ), this, SLOT( onDirBtnClicked() ) );
+ connect( myXCoord, SIGNAL( textChanged(const QString&) ), this, SLOT( checkVertexIsDefined() ) );
+ connect( myYCoord, SIGNAL( textChanged(const QString&) ), this, SLOT( checkVertexIsDefined() ) );
+ connect( myZCoord, SIGNAL( textChanged(const QString&) ), this, SLOT( checkVertexIsDefined() ) );
+ connect( mySizeValue, SIGNAL( textChanged(const QString&) ), this, SLOT( checkVertexIsDefined() ) );
+ connect( this, SIGNAL( vertexDefined(bool) ), addVertexButton, SLOT( setEnabled(bool) ) );
+ connect( addVertexButton, SIGNAL( clicked() ), this, SLOT( onVertexBtnClicked() ) );
+ connect( removeVertexButton, SIGNAL( clicked() ), this, SLOT( onRemoveVertexBtnClicked() ) );
+
+
+
+ return fr;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::smpVertexExists(double x, double y, double z) const
+{
+ const int rowCount = mySmpModel->rowCount();
+ for (int i=0 ; i < rowCount ; i++) {
+ double myX = mySmpModel->data(mySmpModel->index(i, ENF_VER_X_COLUMN)).toDouble();
+ if (myX == x) {
+// MESSAGE("Found x value " << x << " at row " << i);
+ double myY = mySmpModel->data(mySmpModel->index(i, ENF_VER_Y_COLUMN)).toDouble();
+ if (myY == y) {
+// MESSAGE("Found y value " << y << " at row " << i);
+ double myZ = mySmpModel->data(mySmpModel->index(i, ENF_VER_Z_COLUMN)).toDouble();
+ if (myZ == z) {
+ if (MYDEBUG){
+ MESSAGE("Found x value " << x << " at row " << i);
+ MESSAGE("Found y value " << y << " at row " << i);
+ MESSAGE("Found z value " << z << " at row " << i);
+ }
+ return true;
+ }
+ }
+ }
+ }
+// MESSAGE("Not found x,y,z values: " << x << " " << y << " " << z);
+ return false;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::checkVertexIsDefined()
+{
+ bool val = (!myXCoord->text().isEmpty())&&(!myYCoord->text().isEmpty())&&(!myZCoord->text().isEmpty())&&(!mySizeValue->text().isEmpty());
+ bool isDefined = val;
+ if (val)
+ isDefined = ! smpVertexExists(myXCoord->text().toDouble(),myYCoord->text().toDouble(),myZCoord->text().toDouble());
+
+ emit vertexDefined(isDefined);
+ return isDefined;
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::onVertexBtnClicked()
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::onVertexBtnClicked()");
+ const int row = mySmpModel->rowCount() ;
+ double x = myXCoord->text().toDouble();
+ double y = myYCoord->text().toDouble();
+ double z = myZCoord->text().toDouble();
+ double size = mySizeValue->text().toDouble();
+
+ if (smpVertexExists(x,y,z)) return;
+
+// double size = 10.0;
+ // ENF_VER_X_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_X_COLUMN),x);
+ mySmpModel->setItem( row, ENF_VER_X_COLUMN, new QStandardItem(QString::number(x)) );
+ mySmpModel->item( row, ENF_VER_X_COLUMN )->setFlags( Qt::ItemIsSelectable );
+ // ENF_VER_Y_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_Y_COLUMN),y);
+ mySmpModel->setItem( row, ENF_VER_Y_COLUMN, new QStandardItem(QString::number(y)) );
+ mySmpModel->item( row, ENF_VER_Y_COLUMN )->setFlags( Qt::ItemIsSelectable );
+ // ENF_VER_Z_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_Z_COLUMN),z);
+ mySmpModel->setItem( row, ENF_VER_Z_COLUMN, new QStandardItem(QString::number(z)) );
+ mySmpModel->item( row, ENF_VER_Z_COLUMN )->setFlags( Qt::ItemIsSelectable );
+ // ENF_VER_SIZE_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_SIZE_COLUMN),size);
+ mySmpModel->setItem( row, ENF_VER_SIZE_COLUMN, new QStandardItem(QString::number(size,'f')) );
+
+ myEnforcedTableView->clearSelection();
+ myEnforcedTableView->scrollTo( mySmpModel->item( row, ENF_VER_SIZE_COLUMN )->index() );
+ checkVertexIsDefined();
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::onRemoveVertexBtnClicked()
+{
+ QList<int> selectedRows;
+ QList<QModelIndex> selectedIndex = myEnforcedTableView->selectionModel()->selectedIndexes();
+ int row;
+ QModelIndex index;
+ foreach( index, selectedIndex ) {
+ row = index.row();
+ if ( !selectedRows.contains( row ) )
+ selectedRows.append( row );
+ }
+ qSort( selectedRows );
+ QListIterator<int> it( selectedRows );
+ it.toBack();
+ while ( it.hasPrevious() ) {
+ row = it.previous();
+ if (MYDEBUG) MESSAGE("delete row #"<< row);
+ mySmpModel->removeRow(row );
+ }
+ myEnforcedTableView->clearSelection();
+}
+void HEXABLOCKPluginGUI_HypothesisCreator::onDirBtnClicked()
+{
+ QString dir = SUIT_FileDlg::getExistingDirectory( dlg(), myWorkingDir->text(), QString() );
+ if ( !dir.isEmpty() )
+ myWorkingDir->setText( dir );
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::updateWidgets()
+{
+ myMaximumMemorySpin->setEnabled( myMaximumMemoryCheck->isChecked() );
+ myInitialMemoryCheck->setEnabled( !myBoundaryRecoveryCheck->isChecked() );
+ myInitialMemorySpin->setEnabled( myInitialMemoryCheck->isChecked() && !myBoundaryRecoveryCheck->isChecked() );
+ myOptimizationLevelCombo->setEnabled( !myBoundaryRecoveryCheck->isChecked() );
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::checkParams(QString& msg) const
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::checkParams");
+
+ if ( !QFileInfo( myWorkingDir->text().trimmed() ).isWritable() ) {
+ SUIT_MessageBox::warning( dlg(),
+ tr( "SMESH_WRN_WARNING" ),
+ tr( "HEXABLOCK_PERMISSION_DENIED" ) );
+ return false;
+ }
+
+ return true;
+}
+
+void HEXABLOCKPluginGUI_HypothesisCreator::retrieveParams() const
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::retrieveParams");
+ HEXABLOCKHypothesisData data;
+ readParamsFromHypo( data );
+
+ if ( myName )
+ myName->setText( data.myName );
+
+ myToMeshHolesCheck ->setChecked ( data.myToMeshHoles );
+ myOptimizationLevelCombo ->setCurrentIndex( data.myOptimizationLevel );
+ myMaximumMemoryCheck ->setChecked ( data.myMaximumMemory > 0 );
+ myMaximumMemorySpin ->setValue ( qMax( data.myMaximumMemory,
+ myMaximumMemorySpin->minimum() ));
+ myInitialMemoryCheck ->setChecked ( data.myInitialMemory > 0 );
+ myInitialMemorySpin ->setValue ( qMax( data.myInitialMemory,
+ myInitialMemorySpin->minimum() ));
+ myWorkingDir ->setText ( data.myWorkingDir );
+ myKeepFiles ->setChecked ( data.myKeepFiles );
+ myVerboseLevelSpin ->setValue ( data.myVerboseLevel );
+ myToCreateNewNodesCheck ->setChecked ( data.myToCreateNewNodes );
+ myRemoveInitialCentralPointCheck ->setChecked ( data.myRemoveInitialCentralPoint );
+ myBoundaryRecoveryCheck ->setChecked ( data.myBoundaryRecovery );
+ myFEMCorrectionCheck ->setChecked ( data.myFEMCorrection );
+ myTextOption ->setText ( data.myTextOption );
+
+ TEnforcedVertexValues::const_iterator it;
+ int row = 0;
+ for(it = data.myEnforcedVertices.begin() ; it != data.myEnforcedVertices.end(); it++ )
+ {
+ double x = it->at(0);
+ double y = it->at(1);
+ double z = it->at(2);
+ double size = it->at(3);
+ // ENF_VER_X_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_X_COLUMN),x);
+ mySmpModel->setItem( row, ENF_VER_X_COLUMN, new QStandardItem(QString::number(x)) );
+ mySmpModel->item( row, ENF_VER_X_COLUMN )->setFlags( Qt::ItemIsSelectable );
+ // ENF_VER_Y_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_Y_COLUMN),y);
+ mySmpModel->setItem( row, ENF_VER_Y_COLUMN, new QStandardItem(QString::number(y)) );
+ mySmpModel->item( row, ENF_VER_Y_COLUMN )->setFlags( Qt::ItemIsSelectable );
+ // ENF_VER_Z_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_Z_COLUMN),z);
+ mySmpModel->setItem( row, ENF_VER_Z_COLUMN, new QStandardItem(QString::number(z)) );
+ mySmpModel->item( row, ENF_VER_Z_COLUMN )->setFlags( Qt::ItemIsSelectable );
+ // ENF_VER_SIZE_COLUMN
+ mySmpModel->setData(mySmpModel->index(row, ENF_VER_SIZE_COLUMN),size);
+ mySmpModel->setItem( row, ENF_VER_SIZE_COLUMN, new QStandardItem(QString::number(size)) );
+
+ if (MYDEBUG) MESSAGE("Row " << row << ": (" << x << ","<< y << ","<< z << ") ="<< size);
+ row++;
+ }
+
+ HEXABLOCKPluginGUI_HypothesisCreator* that = (HEXABLOCKPluginGUI_HypothesisCreator*)this;
+ that->updateWidgets();
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::storeParams() const
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::storeParams");
+ HEXABLOCKHypothesisData data;
+ readParamsFromWidgets( data );
+ storeParamsToHypo( data );
+
+ QString valStr = "";
+
+ if ( !data.myBoundaryRecovery )
+ valStr = "-c " + QString::number( !data.myToMeshHoles );
+
+ if ( data.myOptimizationLevel >= 0 && data.myOptimizationLevel < 5 && !data.myBoundaryRecovery) {
+ const char* level[] = { "none" , "light" , "standard" , "standard+" , "strong" };
+ valStr += " -o ";
+ valStr += level[ data.myOptimizationLevel ];
+ }
+ if ( data.myMaximumMemory > 0 ) {
+ valStr += " -m ";
+ valStr += QString::number( data.myMaximumMemory );
+ }
+ if ( data.myInitialMemory > 0 && !data.myBoundaryRecovery ) {
+ valStr += " -M ";
+ valStr += QString::number( data.myInitialMemory );
+ }
+ valStr += " -v ";
+ valStr += QString::number( data.myVerboseLevel );
+
+ if ( !data.myToCreateNewNodes )
+ valStr += " -p0";
+
+ if ( data.myRemoveInitialCentralPoint )
+ valStr += " -no_initial_central_point";
+
+ if ( data.myBoundaryRecovery )
+ valStr += " -C";
+
+ if ( data.myFEMCorrection )
+ valStr += " -FEM";
+
+ valStr += " ";
+ valStr += data.myTextOption;
+
+ valStr += " #BEGIN ENFORCED VERTICES#";
+ // Add size map parameters storage
+ for (int i=0 ; i<mySmpModel->rowCount() ; i++) {
+ valStr += " (";
+ double x = mySmpModel->data(mySmpModel->index(i,ENF_VER_X_COLUMN)).toDouble();
+ double y = mySmpModel->data(mySmpModel->index(i,ENF_VER_Y_COLUMN)).toDouble();
+ double z = mySmpModel->data(mySmpModel->index(i,ENF_VER_Z_COLUMN)).toDouble();
+ double size = mySmpModel->data(mySmpModel->index(i,ENF_VER_SIZE_COLUMN)).toDouble();
+ valStr += QString::number( x );
+ valStr += ",";
+ valStr += QString::number( y );
+ valStr += ",";
+ valStr += QString::number( z );
+ valStr += ")=";
+ valStr += QString::number( size );
+ if (i!=mySmpModel->rowCount()-1)
+ valStr += ";";
+ }
+ valStr += " #END ENFORCED VERTICES#";
+ if (MYDEBUG) MESSAGE(valStr.toStdString());
+ return valStr;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromHypo( HEXABLOCKHypothesisData& h_data ) const
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromHypo");
+ HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis_var h =
+ HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis::_narrow( initParamsHypothesis() );
+
+ HypothesisData* data = SMESH::GetHypothesisData( hypType() );
+ h_data.myName = isCreation() && data ? hypName() : "";
+
+ /* fkl to update:
+ h_data.myToMeshHoles = h->GetToMeshHoles();
+ h_data.myMaximumMemory = h->GetMaximumMemory();
+ h_data.myInitialMemory = h->GetInitialMemory();
+ h_data.myInitialMemory = h->GetInitialMemory();
+ h_data.myOptimizationLevel = h->GetOptimizationLevel();
+ h_data.myKeepFiles = h->GetKeepFiles();
+ h_data.myWorkingDir = h->GetWorkingDirectory();
+ h_data.myVerboseLevel = h->GetVerboseLevel();
+ h_data.myToCreateNewNodes = h->GetToCreateNewNodes();
+ h_data.myRemoveInitialCentralPoint = h->GetToRemoveCentralPoint();
+ h_data.myBoundaryRecovery = h->GetToUseBoundaryRecoveryVersion();
+ h_data.myFEMCorrection = h->GetFEMCorrection();
+ h_data.myTextOption = h->GetTextOption();
+
+ HEXABLOCKPlugin::HEXABLOCKEnforcedVertexList_var vertices = h->GetEnforcedVertices();
+ MESSAGE("vertices->length(): " << vertices->length());
+ h_data.myEnforcedVertices.clear();
+ for (int i=0 ; i<vertices->length() ; i++) {
+ HEXABLOCKEnforcedVertex myVertex;
+ myVertex.push_back(vertices[i].x);
+ myVertex.push_back(vertices[i].y);
+ myVertex.push_back(vertices[i].z);
+ myVertex.push_back(vertices[i].size);
+ MESSAGE("Add enforced vertex ("<< myVertex[0] << ","<< myVertex[1] << ","<< myVertex[2] << ") ="<< myVertex[3]);
+ h_data.myEnforcedVertices.push_back(myVertex);
+ }
+ */
+
+ return true;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::storeParamsToHypo( const HEXABLOCKHypothesisData& h_data ) const
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::storeParamsToHypo");
+ HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis_var h =
+ HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis::_narrow( hypothesis() );
+
+ bool ok = true;
+ try
+ {
+ if( isCreation() )
+ SMESH::SetName( SMESH::FindSObject( h ), h_data.myName.toLatin1().constData() );
+
+ /* fkl to update:
+ if ( h->GetToMeshHoles() != h_data.myToMeshHoles ) // avoid duplication of DumpPython commands
+ h->SetToMeshHoles ( h_data.myToMeshHoles );
+ if ( h->GetMaximumMemory() != h_data.myMaximumMemory )
+ h->SetMaximumMemory ( h_data.myMaximumMemory );
+ if ( h->GetInitialMemory() != h_data.myInitialMemory )
+ h->SetInitialMemory ( h_data.myInitialMemory );
+ if ( h->GetInitialMemory() != h_data.myInitialMemory )
+ h->SetInitialMemory ( h_data.myInitialMemory );
+ if ( h->GetOptimizationLevel() != h_data.myOptimizationLevel )
+ h->SetOptimizationLevel( h_data.myOptimizationLevel );
+ if ( h->GetKeepFiles() != h_data.myKeepFiles )
+ h->SetKeepFiles ( h_data.myKeepFiles );
+ if ( h->GetWorkingDirectory() != h_data.myWorkingDir )
+ h->SetWorkingDirectory ( h_data.myWorkingDir.toLatin1().constData() );
+ if ( h->GetVerboseLevel() != h_data.myVerboseLevel )
+ h->SetVerboseLevel ( h_data.myVerboseLevel );
+ if ( h->GetToCreateNewNodes() != h_data.myToCreateNewNodes )
+ h->SetToCreateNewNodes( h_data.myToCreateNewNodes );
+ if ( h->GetToRemoveCentralPoint() != h_data.myRemoveInitialCentralPoint )
+ h->SetToRemoveCentralPoint( h_data.myRemoveInitialCentralPoint );
+ if ( h->GetToUseBoundaryRecoveryVersion() != h_data.myBoundaryRecovery )
+ h->SetToUseBoundaryRecoveryVersion( h_data.myBoundaryRecovery );
+ if ( h->GetFEMCorrection() != h_data.myFEMCorrection )
+ h->SetFEMCorrection( h_data.myFEMCorrection );
+ if ( h->GetTextOption() != h_data.myTextOption )
+ h->SetTextOption ( h_data.myTextOption.toLatin1().constData() );
+
+ int nbVertex = (int) h_data.myEnforcedVertices.size();
+ HEXABLOCKPlugin::HEXABLOCKEnforcedVertexList_var vertexHyp = h->GetEnforcedVertices();
+ int nbVertexHyp = vertexHyp->length();
+
+ MESSAGE("Store params for size maps: " << nbVertex << " enforced vertices");
+ MESSAGE("h->GetEnforcedVertices()->length(): " << nbVertexHyp);
+
+ // Some vertices were removed
+ if (nbVertex < nbVertexHyp) {
+// if (nbVertex == 0)
+// h->ClearEnforcedVertices();
+// else {
+ // iterate over vertices of hypo
+ for(int i = 0 ; i <nbVertexHyp ; i++) {
+ double x = vertexHyp[i].x;
+ double y = vertexHyp[i].y;
+ double z = vertexHyp[i].z;
+ // vertex is removed
+ if (!smpVertexExists(x,y,z))
+ h->RemoveEnforcedVertex(x,y,z);
+ }
+// }
+ }
+
+ TEnforcedVertexValues::const_iterator it;
+ for(it = h_data.myEnforcedVertices.begin() ; it != h_data.myEnforcedVertices.end(); it++ ) {
+ double x = it->at(0);
+ double y = it->at(1);
+ double z = it->at(2);
+ double size = it->at(3);
+ MESSAGE("(" << x << ", "
+ << y << ", "
+ << z << ") = "
+ << size );
+ double mySize;
+ try {
+ mySize = h->GetEnforcedVertex(x,y,z);
+ MESSAGE("Old size: " << mySize);
+ if (mySize != size) {
+ MESSAGE("Setting new size: " << size);
+ h->SetEnforcedVertex(x,y,z,size);
+ }
+ }
+ catch (...) {
+ MESSAGE("Setting new size: " << size);
+ h->SetEnforcedVertex(x,y,z,size);
+ }
+ }
+ */
+ }
+ catch ( const SALOME::SALOME_Exception& ex )
+ {
+ SalomeApp_Tools::QtCatchCorbaException( ex );
+ ok = false;
+ }
+ return ok;
+}
+
+bool HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromWidgets( HEXABLOCKHypothesisData& h_data ) const
+{
+ if (MYDEBUG) MESSAGE("HEXABLOCKPluginGUI_HypothesisCreator::readParamsFromWidgets");
+ h_data.myName = myName ? myName->text() : "";
+ h_data.myToMeshHoles = myToMeshHolesCheck->isChecked();
+ h_data.myMaximumMemory = myMaximumMemoryCheck->isChecked() ? myMaximumMemorySpin->value() : -1;
+ h_data.myInitialMemory = myInitialMemoryCheck->isChecked() ? myInitialMemorySpin->value() : -1;
+ h_data.myOptimizationLevel = myOptimizationLevelCombo->currentIndex();
+ h_data.myKeepFiles = myKeepFiles->isChecked();
+ h_data.myWorkingDir = myWorkingDir->text().trimmed();
+ h_data.myVerboseLevel = myVerboseLevelSpin->value();
+ h_data.myToCreateNewNodes = myToCreateNewNodesCheck->isChecked();
+ h_data.myRemoveInitialCentralPoint = myRemoveInitialCentralPointCheck->isChecked();
+ h_data.myBoundaryRecovery = myBoundaryRecoveryCheck->isChecked();
+ h_data.myFEMCorrection = myFEMCorrectionCheck->isChecked();
+ h_data.myTextOption = myTextOption->text();
+ h_data.myEnforcedVertices.clear();
+
+ for (int i=0 ; i<mySmpModel->rowCount() ; i++) {
+ HEXABLOCKEnforcedVertex myVertex;
+ myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_X_COLUMN)).toDouble());
+ myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_Y_COLUMN)).toDouble());
+ myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_Z_COLUMN)).toDouble());
+ myVertex.push_back(mySmpModel->data(mySmpModel->index(i,ENF_VER_SIZE_COLUMN)).toDouble());
+ if (MYDEBUG) MESSAGE("Add new enforced vertex (" << myVertex[0] << ", "
+ << myVertex[1] << ", "
+ << myVertex[2] << ") = "
+ << myVertex[3]);
+ h_data.myEnforcedVertices.push_back(myVertex);
+ }
+
+ return true;
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::caption() const
+{
+ return tr( "HEXABLOCK_TITLE" );
+}
+
+QPixmap HEXABLOCKPluginGUI_HypothesisCreator::icon() const
+{
+ return SUIT_Session::session()->resourceMgr()->loadPixmap( "HEXABLOCKPlugin", tr( "ICON_DLG_HEXABLOCK_PARAMETERS" ) );
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::type() const
+{
+ return tr( "HEXABLOCK_HYPOTHESIS" );
+}
+
+QString HEXABLOCKPluginGUI_HypothesisCreator::helpPage() const
+{
+ return "HEXABLOCK_hypo_page.html";
+}
+
+//=============================================================================
+/*! GetHypothesisCreator
+ *
+ */
+//=============================================================================
+extern "C"
+{
+ HEXABLOCKPLUGINGUI_EXPORT
+ SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator( const QString& aHypType )
+ {
+ if ( aHypType == "HEXABLOCK_Parameters" )
+ return new HEXABLOCKPluginGUI_HypothesisCreator( aHypType );
+ return 0;
+ }
+}
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// HEXABLOCKPlugin GUI: GUI for plugged-in mesher HEXABLOCKPlugin
+// File : HEXABLOCKPluginGUI_HypothesisCreator.h
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Module : HEXABLOCKPlugin
+//
+#ifndef HEXABLOCKPLUGINGUI_HypothesisCreator_HeaderFile
+#define HEXABLOCKPLUGINGUI_HypothesisCreator_HeaderFile
+
+#ifdef WIN32
+ #if defined HEXABLOCKPluginGUI_EXPORTS
+ #define HEXABLOCKPLUGINGUI_EXPORT __declspec( dllexport )
+ #else
+ #define HEXABLOCKPLUGINGUI_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define HEXABLOCKPLUGINGUI_EXPORT
+#endif
+
+#include <SMESHGUI_Hypotheses.h>
+// #include <SalomeApp_DoubleSpinBox.h>
+
+#include <QItemDelegate>
+#include <map>
+#include <vector>
+#include CORBA_SERVER_HEADER(HEXABLOCKPlugin_Algorithm)
+
+class QWidget;
+class QComboBox;
+class QCheckBox;
+class QLineEdit;
+class QSpinBox;
+class QStandardItemModel;
+class QTableView;
+class QHeaderView;
+class QDoubleSpinBox;
+
+class LightApp_SelectionMgr;
+
+typedef std::vector<double> HEXABLOCKEnforcedVertex;
+typedef std::vector<HEXABLOCKEnforcedVertex> TEnforcedVertexValues;
+
+typedef struct
+{
+ bool myToMeshHoles,myKeepFiles,myToCreateNewNodes,myBoundaryRecovery,myFEMCorrection,myRemoveInitialCentralPoint;
+ int myMaximumMemory,myInitialMemory,myOptimizationLevel;
+ QString myName,myWorkingDir,myTextOption;
+ short myVerboseLevel;
+ TEnforcedVertexValues myEnforcedVertices;
+} HEXABLOCKHypothesisData;
+
+/*!
+ \brief Class for creation of HEXABLOCK2D and HEXABLOCK3D hypotheses
+*/
+class HEXABLOCKPLUGINGUI_EXPORT HEXABLOCKPluginGUI_HypothesisCreator : public SMESHGUI_GenericHypothesisCreator
+{
+ Q_OBJECT
+
+public:
+ HEXABLOCKPluginGUI_HypothesisCreator( const QString& );
+ virtual ~HEXABLOCKPluginGUI_HypothesisCreator();
+
+ virtual bool checkParams(QString& msg) const;
+ virtual QString helpPage() const;
+
+protected:
+ virtual QFrame* buildFrame ();
+ virtual void retrieveParams() const;
+ virtual QString storeParams () const;
+
+ virtual QString caption() const;
+ virtual QPixmap icon() const;
+ virtual QString type() const;
+
+protected slots:
+ void onDirBtnClicked();
+ void updateWidgets();
+ void onVertexBtnClicked();
+ void onRemoveVertexBtnClicked();
+ bool checkVertexIsDefined();
+
+signals:
+ void vertexDefined(bool);
+
+private:
+ bool readParamsFromHypo( HEXABLOCKHypothesisData& ) const;
+ bool readParamsFromWidgets( HEXABLOCKHypothesisData& ) const;
+ bool storeParamsToHypo( const HEXABLOCKHypothesisData& ) const;
+ bool smpVertexExists(double, double, double) const;
+
+private:
+ QWidget* myStdGroup;
+ QLineEdit* myName;
+ QCheckBox* myToMeshHolesCheck;
+ QComboBox* myOptimizationLevelCombo;
+
+ QWidget* myAdvGroup;
+ QCheckBox* myMaximumMemoryCheck;
+ QSpinBox* myMaximumMemorySpin;
+ QCheckBox* myInitialMemoryCheck;
+ QSpinBox* myInitialMemorySpin;
+ QLineEdit* myWorkingDir;
+ QCheckBox* myKeepFiles;
+ QSpinBox* myVerboseLevelSpin;
+ QCheckBox* myToCreateNewNodesCheck;
+ QCheckBox* myRemoveInitialCentralPointCheck;
+ QCheckBox* myBoundaryRecoveryCheck;
+ QCheckBox* myFEMCorrectionCheck;
+QLineEdit* myTextOption;
+
+ QWidget* myEnfGroup;
+ QStandardItemModel* mySmpModel;
+ QTableView* myEnforcedTableView;
+ QLineEdit* myXCoord;
+ QLineEdit* myYCoord;
+ QLineEdit* myZCoord;
+ QLineEdit* mySizeValue;
+ QPushButton* addVertexButton;
+ QPushButton* removeVertexButton;
+
+ LightApp_SelectionMgr* mySelectionMgr; /* User shape selection */
+// SVTK_Selector* mySelector;
+};
+
+class DoubleLineEditDelegate : public QItemDelegate
+{
+ Q_OBJECT
+
+public:
+ DoubleLineEditDelegate(QObject *parent = 0);
+
+ QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
+ const QModelIndex &index) const;
+
+ void setEditorData(QWidget *editor, const QModelIndex &index) const;
+ void setModelData(QWidget *editor, QAbstractItemModel *model,
+ const QModelIndex &index) const;
+
+ void updateEditorGeometry(QWidget *editor,
+ const QStyleOptionViewItem &option, const QModelIndex &index) const;
+};
+
+#endif
--- /dev/null
+<!DOCTYPE TS>
+<!--
+ Copyright (C) 2009-2011 CEA/DEN, EDF R&D
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+<TS version="1.1" >
+ <context>
+ <name>@default</name>
+ <message>
+ <source>ICON_DLG_HEXABLOCK_PARAMETERS</source>
+ <translation>mesh_hypo_HEXABLOCK.png</translation>
+ </message>
+ <message>
+ <source>ICON_SMESH_TREE_ALGO_HEXABLOCK_3D</source>
+ <translation>mesh_tree_hypo_HEXABLOCK.png</translation>
+ </message>
+ <message>
+ <source>ICON_SMESH_TREE_HYPO_HEXABLOCK_Parameters</source>
+ <translation>mesh_tree_hypo_HEXABLOCK.png</translation>
+ </message>
+ </context>
+</TS>
--- /dev/null
+<!DOCTYPE TS>
+<!--
+ Copyright (C) 2009-2011 CEA/DEN, EDF R&D
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+
+-->
+<TS version="1.1" >
+ <context>
+ <name>@default</name>
+ <message>
+ <source>HEXABLOCK_ADV_ARGS</source>
+ <translation>Advanced</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_HYPOTHESIS</source>
+ <translation>HEXABLOCK</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_OPTIMIZATIOL_LEVEL</source>
+ <translation>Optimization level</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_PERMISSION_DENIED</source>
+ <translation>Working directory is not writable</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_STD_ARGS</source>
+ <translation>Parameters</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_TITLE</source>
+ <translation>Hypothesis Construction</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_TO_MESH_HOLES</source>
+ <translation>To mesh holes</translation>
+ </message>
+ <message>
+ <source>INIT_MEMORY_SIZE</source>
+ <translation>Initial memory size</translation>
+ </message>
+ <message>
+ <source>KEEP_WORKING_FILES</source>
+ <translation>To keep working files</translation>
+ </message>
+ <message>
+ <source>LEVEL_NONE</source>
+ <translation>None</translation>
+ </message>
+ <message>
+ <source>LEVEL_LIGHT</source>
+ <translation>Light</translation>
+ </message>
+ <message>
+ <source>LEVEL_MEDIUM</source>
+ <translation>Medium (standard)</translation>
+ </message>
+ <message>
+ <source>LEVEL_STANDARDPLUS</source>
+ <translation>Standard+</translation>
+ </message>
+ <message>
+ <source>LEVEL_STRONG</source>
+ <translation>Strong</translation>
+ </message>
+ <message>
+ <source>MAX_MEMORY_SIZE</source>
+ <translation>Maximum memory size</translation>
+ </message>
+ <message>
+ <source>MEGABYTE</source>
+ <translation>Megabytes</translation>
+ </message>
+ <message>
+ <source>NO_INITIAL_CENTRAL_POINT</source>
+ <translation>To remove initial central point</translation>
+ </message>
+ <message>
+ <source>RECOVERY_VERSION</source>
+ <translation>To use boundary recovery version</translation>
+ </message>
+ <message>
+ <source>FEM_CORRECTION</source>
+ <translation>To use FEM correction</translation>
+ </message>
+ <message>
+ <source>SELECT_DIR</source>
+ <translation>...</translation>
+ </message>
+ <message>
+ <source>TEXT_OPTION</source>
+ <translation>Option as text</translation>
+ </message>
+ <message>
+ <source>TO_ADD_NODES</source>
+ <translation>To create new nodes</translation>
+ </message>
+ <message>
+ <source>VERBOSE_LEVEL</source>
+ <translation>Verbose level</translation>
+ </message>
+ <message>
+ <source>WORKING_DIR</source>
+ <translation>Working directory</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENFORCED_VERTICES</source>
+ <translation>Enforced vertices</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_X_COLUMN</source>
+ <translation>X</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_Y_COLUMN</source>
+ <translation>Y</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_Z_COLUMN</source>
+ <translation>Z</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_SIZE_COLUMN</source>
+ <translation>Size</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_X_LABEL</source>
+ <translation>X:</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_Y_LABEL</source>
+ <translation>Y:</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_Z_LABEL</source>
+ <translation>Z:</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_SIZE_LABEL</source>
+ <translation>Size:</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_VERTEX</source>
+ <translation>Add enforced vertex</translation>
+ </message>
+ <message>
+ <source>HEXABLOCK_ENF_VER_REMOVE</source>
+ <translation>Remove vertex</translation>
+ </message>
+ </context>
+</TS>
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# Module : HEXABLOCKPLUGIN
+# Date : 2010/11/08
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# header files
+salomeinclude_HEADERS =
+
+# Libraries targets
+lib_LTLIBRARIES = libHEXABLOCKPluginGUI.la
+
+dist_libHEXABLOCKPluginGUI_la_SOURCES = HEXABLOCKPluginGUI_HypothesisCreator.cxx
+
+MOC_FILES = HEXABLOCKPluginGUI_HypothesisCreator_moc.cxx
+nodist_libHEXABLOCKPluginGUI_la_SOURCES= $(MOC_FILES)
+
+libHEXABLOCKPluginGUI_la_CPPFLAGS = \
+ $(QT_INCLUDES) \
+ $(KERNEL_CXXFLAGS) \
+ $(GUI_CXXFLAGS) \
+ $(GEOM_CXXFLAGS) \
+ $(HEXABLOCK_CXXFLAGS) \
+ $(MED_CXXFLAGS) \
+ $(SMESH_CXXFLAGS) \
+ $(BOOST_CPPFLAGS) \
+ $(CORBA_CXXFLAGS) \
+ $(CORBA_INCLUDES) \
+ $(CAS_CPPFLAGS) \
+ -I$(srcdir)/.. \
+ -I$(top_builddir)/idl
+
+libHEXABLOCKPluginGUI_la_LDFLAGS = \
+ ../../idl/libSalomeIDLHEXABLOCKPLUGIN.la \
+ $(QT_LIBS) \
+ $(KERNEL_LDFLAGS) -lSALOMELocalTrace \
+ $(HEXABLOCK_LDFLAGS) -lSalomeIDLHEXABLOCK \
+ $(MED_LDFLAGS) -lSalomeIDLMED \
+ $(SMESH_LDFLAGS) -lSMESH \
+ $(GUI_LDFLAGS) -lsuit -lqtx -lSalomeApp \
+ $(CAS_KERNEL)
+
+# resources files
+nodist_salomeres_DATA= \
+ HEXABLOCKPlugin_images.qm \
+ HEXABLOCKPlugin_msg_en.qm
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File : HEXABLOCKPlugin_Defs.hxx
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+//
+#ifndef _HEXABLOCKPlugin_DEFS_HXX_
+#define _HEXABLOCKPlugin_DEFS_HXX_
+
+#ifdef WIN32
+ #if defined HEXABLOCKPLUGIN_EXPORTS || defined HEXABLOCKEngine_EXPORTS
+ #define HEXABLOCKPLUGIN_EXPORT __declspec( dllexport )
+ #else
+ #define HEXABLOCKPLUGIN_EXPORT __declspec( dllimport )
+ #endif
+#else
+ #define HEXABLOCKPLUGIN_EXPORT
+#endif
+
+#endif
--- /dev/null
+// Copyright (C) 2009-2011 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : SMESH_HexaFromSkin_3D.cxx
+// Created : Wed Jan 27 12:28:07 2010
+// Author : Edward AGAPOV (eap)
+//
+#include "HEXABLOCKPlugin_FromSkin_3D.hxx"
+
+#include "SMDS_VolumeOfNodes.hxx"
+#include "SMDS_VolumeTool.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_MesherHelper.hxx"
+
+#include <gp_Ax2.hxx>
+
+//#include "utilities.h"
+#include <limits>
+
+// Define error message and _MYDEBUG_ if needed
+#ifdef _DEBUG_
+#define BAD_MESH_ERR \
+ error(SMESH_Comment("Can't detect block-wise structure of the input 2D mesh.\n" \
+ __FILE__ ":" )<<__LINE__)
+//#define _MYDEBUG_
+#else
+#define BAD_MESH_ERR \
+ error(SMESH_Comment("Can't detect block-wise structure of the input 2D mesh"))
+#endif
+
+// Debug output
+#ifdef _MYDEBUG_
+#define _DUMP_(msg) cout << msg << endl
+#else
+#define _DUMP_(msg)
+#endif
+
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+namespace
+{
+ enum EBoxSides //!< sides of the block
+ {
+ B_BOTTOM=0, B_RIGHT, B_TOP, B_LEFT, B_FRONT, B_BACK, NB_BLOCK_SIDES
+ };
+#ifdef _MYDEBUG_
+ const char* SBoxSides[] = //!< names of block sides
+ {
+ "BOTTOM", "RIGHT", "TOP", "LEFT", "FRONT", "BACK", "UNDEFINED"
+ };
+#endif
+ enum EQuadEdge //!< edges of quadrangle side
+ {
+ Q_BOTTOM = 0, Q_RIGHT, Q_TOP, Q_LEFT, NB_QUAD_SIDES
+ };
+
+
+ //================================================================================
+ /*!
+ * \brief return logical coordinates (i.e. min or max) of ends of edge
+ */
+ //================================================================================
+
+ bool getEdgeEnds(EQuadEdge edge, bool& xMax1, bool& yMax1, bool& xMax2, bool& yMax2 )
+ {
+ xMax1=0, yMax1=0, xMax2=1, yMax2=1;
+ switch( edge )
+ {
+ case Q_BOTTOM: yMax2 = 0; break;
+ case Q_RIGHT: xMax1 = 1; break;
+ case Q_TOP: yMax1 = 1; break;
+ case Q_LEFT: xMax2 = 0; break;
+ default:
+ return false;
+ }
+ return true;
+ }
+
+ //================================================================================
+ /*!
+ * \brief return true if a node is at block corner
+ *
+ * This check is valid for simple cases only
+ */
+ //================================================================================
+
+ bool isCornerNode( const SMDS_MeshNode* n )
+ {
+ int nbF = n ? n->NbInverseElements( SMDSAbs_Face ) : 1;
+ if ( nbF % 2 )
+ return true;
+
+ set<const SMDS_MeshNode*> nodesInInverseFaces;
+ SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face );
+ while ( fIt->more() )
+ {
+ const SMDS_MeshElement* face = fIt->next();
+ nodesInInverseFaces.insert( face->begin_nodes(), face->end_nodes() );
+ }
+
+ return nodesInInverseFaces.size() != ( 6 + (nbF/2-1)*3 );
+ }
+
+ //================================================================================
+ /*!
+ * \brief check element type
+ */
+ //================================================================================
+
+ bool isQuadrangle(const SMDS_MeshElement* e)
+ {
+ return ( e && e->NbCornerNodes() == 4 );
+ }
+
+ //================================================================================
+ /*!
+ * \brief return opposite node of a quadrangle face
+ */
+ //================================================================================
+
+ const SMDS_MeshNode* oppositeNode(const SMDS_MeshElement* quad, int iNode)
+ {
+ return quad->GetNode( (iNode+2) % 4 );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Convertor of a pair of integers to a sole index
+ */
+ struct _Indexer
+ {
+ int _xSize, _ySize;
+ _Indexer( int xSize=0, int ySize=0 ): _xSize(xSize), _ySize(ySize) {}
+ int size() const { return _xSize * _ySize; }
+ int operator()(int x, int y) const { return y * _xSize + x; }
+ };
+ //================================================================================
+ /*!
+ * \brief Oriented convertor of a pair of integers to a sole index
+ */
+ class _OrientedIndexer : public _Indexer
+ {
+ public:
+ enum OriFlags //!< types of block side orientation
+ {
+ REV_X = 1, REV_Y = 2, SWAP_XY = 4, MAX_ORI = REV_X|REV_Y|SWAP_XY
+ };
+ _OrientedIndexer( const _Indexer& indexer, const int oriFlags ):
+ _Indexer( indexer._xSize, indexer._ySize ),
+ _xSize (indexer._xSize), _ySize(indexer._ySize),
+ _xRevFun((oriFlags & REV_X) ? & reverse : & lazy),
+ _yRevFun((oriFlags & REV_Y) ? & reverse : & lazy),
+ _swapFun((oriFlags & SWAP_XY ) ? & swap : & lazy)
+ {
+ (*_swapFun)( _xSize, _ySize );
+ }
+ //!< Return index by XY
+ int operator()(int x, int y) const
+ {
+ (*_xRevFun)( x, const_cast<int&>( _xSize ));
+ (*_yRevFun)( y, const_cast<int&>( _ySize ));
+ (*_swapFun)( x, y );
+ return _Indexer::operator()(x,y);
+ }
+ //!< Return index for a corner
+ int corner(bool xMax, bool yMax) const
+ {
+ int x = xMax, y = yMax, size = 2;
+ (*_xRevFun)( x, size );
+ (*_yRevFun)( y, size );
+ (*_swapFun)( x, y );
+ return _Indexer::operator()(x ? _Indexer::_xSize-1 : 0 , y ? _Indexer::_ySize-1 : 0);
+ }
+ int xSize() const { return _xSize; }
+ int ySize() const { return _ySize; }
+ private:
+ _Indexer _indexer;
+ int _xSize, _ySize;
+
+ typedef void (*TFun)(int& x, int& y);
+ TFun _xRevFun, _yRevFun, _swapFun;
+
+ static void lazy (int&, int&) {}
+ static void reverse(int& x, int& size) { x = size - x - 1; }
+ static void swap (int& x, int& y) { std::swap(x,y); }
+ };
+ //================================================================================
+ /*!
+ * \brief Structure corresponding to the meshed side of block
+ */
+ struct _BlockSide
+ {
+ vector<const SMDS_MeshNode*> _grid;
+ _Indexer _index;
+ int _nbBlocksExpected;
+ int _nbBlocksFound;
+
+#ifdef _DEBUG_ // want to get SIGSEGV in case of invalid index
+#define _grid_access_(pobj, i) pobj->_grid[ ((i) < pobj->_grid.size()) ? i : int(1e100)]
+#else
+#define _grid_access_(pobj, i) pobj->_grid[ i ]
+#endif
+ //!< Return node at XY
+ const SMDS_MeshNode* getNode(int x, int y) const { return _grid_access_(this, _index( x,y ));}
+ //!< Set node at XY
+ void setNode(int x, int y, const SMDS_MeshNode* n) { _grid_access_(this, _index( x,y )) = n; }
+ //!< Return an edge
+ SMESH_OrientedLink getEdge(EQuadEdge edge) const
+ {
+ bool x1, y1, x2, y2; getEdgeEnds( edge, x1, y1, x2, y2 );
+ return SMESH_OrientedLink( getCornerNode ( x1, y1 ), getCornerNode( x2, y2 ));
+ }
+ //!< Return a corner node
+ const SMDS_MeshNode* getCornerNode(bool isXMax, bool isYMax) const
+ {
+ return getNode( isXMax ? _index._xSize-1 : 0 , isYMax ? _index._ySize-1 : 0 );
+ }
+ const SMDS_MeshElement* getCornerFace(const SMDS_MeshNode* cornerNode) const;
+ //!< True if all blocks this side belongs to have been found
+ bool isBound() const { return _nbBlocksExpected <= _nbBlocksFound; }
+ //!< Return coordinates of node at XY
+ gp_XYZ getXYZ(int x, int y) const { return SMESH_TNodeXYZ( getNode( x, y )); }
+ //!< Return gravity center of the four corners and the middle node
+ gp_XYZ getGC() const
+ {
+ gp_XYZ xyz =
+ getXYZ( 0, 0 ) +
+ getXYZ( _index._xSize-1, 0 ) +
+ getXYZ( 0, _index._ySize-1 ) +
+ getXYZ( _index._xSize-1, _index._ySize-1 ) +
+ getXYZ( _index._xSize/2, _index._ySize/2 );
+ return xyz / 5;
+ }
+ //!< Return number of mesh faces
+ int getNbFaces() const { return (_index._xSize-1) * (_index._ySize-1); }
+ };
+ //================================================================================
+ /*!
+ * \brief _BlockSide with changed orientation
+ */
+ struct _OrientedBlockSide
+ {
+ _BlockSide* _side;
+ _OrientedIndexer _index;
+
+ _OrientedBlockSide( _BlockSide* side=0, const int oriFlags=0 ):
+ _side(side), _index(side ? side->_index : _Indexer(), oriFlags ) {}
+ //!< return coordinates by XY
+ gp_XYZ xyz(int x, int y) const
+ {
+ return SMESH_TNodeXYZ( _grid_access_(_side, _index( x, y )) );
+ }
+ //!< safely return a node by XY
+ const SMDS_MeshNode* node(int x, int y) const
+ {
+ int i = _index( x, y );
+ return ( i < 0 || i >= _side->_grid.size()) ? 0 : _side->_grid[i];
+ }
+ //!< Return an edge
+ SMESH_OrientedLink edge(EQuadEdge edge) const
+ {
+ bool x1, y1, x2, y2; getEdgeEnds( edge, x1, y1, x2, y2 );
+ return SMESH_OrientedLink( cornerNode ( x1, y1 ), cornerNode( x2, y2 ));
+ }
+ //!< Return a corner node
+ const SMDS_MeshNode* cornerNode(bool isXMax, bool isYMax) const
+ {
+ return _grid_access_(_side, _index.corner( isXMax, isYMax ));
+ }
+ //!< return its size in nodes
+ int getHoriSize() const { return _index.xSize(); }
+ int getVertSize() const { return _index.ySize(); }
+ //!< True if _side has been initialized
+ operator bool() const { return _side; }
+ //! Direct access to _side
+ const _BlockSide* operator->() const { return _side; }
+ _BlockSide* operator->() { return _side; }
+ };
+ //================================================================================
+ /*!
+ * \brief Meshed skin of block
+ */
+ struct _Block
+ {
+ _OrientedBlockSide _side[6]; // 6 sides of a sub-block
+ set<const SMDS_MeshNode*> _corners;
+
+ const _OrientedBlockSide& getSide(int i) const { return _side[i]; }
+ bool setSide( int i, const _OrientedBlockSide& s)
+ {
+ if (( _side[i] = s ))
+ {
+ _corners.insert( s.cornerNode(0,0));
+ _corners.insert( s.cornerNode(1,0));
+ _corners.insert( s.cornerNode(0,1));
+ _corners.insert( s.cornerNode(1,1));
+ }
+ return s;
+ }
+ void clear() { for (int i=0;i<6;++i) _side[i]=0; _corners.clear(); }
+ bool hasSide( const _OrientedBlockSide& s) const
+ {
+ if ( s ) for (int i=0;i<6;++i) if ( _side[i] && _side[i]._side == s._side ) return true;
+ return false;
+ }
+ int nbSides() const { int n=0; for (int i=0;i<6;++i) if ( _side[i] ) ++n; return n; }
+ bool isValid() const;
+ };
+ //================================================================================
+ /*!
+ * \brief Skin mesh possibly containing several meshed blocks
+ */
+ class _Skin
+ {
+ public:
+
+ int findBlocks(SMESH_Mesh& mesh);
+ //!< return i-th block
+ const _Block& getBlock(int i) const { return _blocks[i]; }
+ //!< return error description
+ const SMESH_Comment& error() const { return _error; }
+
+ private:
+ bool fillSide( _BlockSide& side,
+ const SMDS_MeshElement* cornerQuad,
+ const SMDS_MeshNode* cornerNode);
+ bool fillRowsUntilCorner(const SMDS_MeshElement* quad,
+ const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2,
+ vector<const SMDS_MeshNode*>& verRow1,
+ vector<const SMDS_MeshNode*>& verRow2,
+ bool alongN1N2 );
+ _OrientedBlockSide findBlockSide( EBoxSides startBlockSide,
+ EQuadEdge sharedSideEdge1,
+ EQuadEdge sharedSideEdge2,
+ bool withGeometricAnalysis,
+ set< _BlockSide* >& sidesAround);
+ //!< update own data and data of the side bound to block
+ void setSideBoundToBlock( _BlockSide& side )
+ {
+ if ( side._nbBlocksFound++, side.isBound() )
+ for ( int e = 0; e < int(NB_QUAD_SIDES); ++e )
+ _edge2sides[ side.getEdge( (EQuadEdge) e ) ].erase( &side );
+ }
+ //!< store reason of error
+ int error(const SMESH_Comment& reason) { _error = reason; return 0; }
+
+ SMESH_Comment _error;
+
+ list< _BlockSide > _allSides;
+ vector< _Block > _blocks;
+
+ //map< const SMDS_MeshNode*, set< _BlockSide* > > _corner2sides;
+ map< SMESH_OrientedLink, set< _BlockSide* > > _edge2sides;
+ };
+
+ //================================================================================
+ /*!
+ * \brief Find and return number of submeshes corresponding to blocks
+ */
+ //================================================================================
+
+ int _Skin::findBlocks(SMESH_Mesh& mesh)
+ {
+ SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
+
+ // Find a node at any block corner
+
+ SMDS_NodeIteratorPtr nIt = meshDS->nodesIterator(/*idInceasingOrder=*/true);
+ if ( !nIt->more() ) return error("Empty mesh");
+
+ const SMDS_MeshNode* nCorner = 0;
+ while ( nIt->more() )
+ {
+ nCorner = nIt->next();
+ if ( isCornerNode( nCorner ))
+ break;
+ else
+ nCorner = 0;
+ }
+ if ( !nCorner )
+ return BAD_MESH_ERR;
+
+ // --------------------------------------------------------------------
+ // Find all block sides starting from mesh faces sharing the corner node
+ // --------------------------------------------------------------------
+
+ int nbFacesOnSides = 0;
+ TIDSortedElemSet cornerFaces; // corner faces of found _BlockSide's
+ list< const SMDS_MeshNode* > corners( 1, nCorner );
+ list< const SMDS_MeshNode* >::iterator corner = corners.begin();
+ while ( corner != corners.end() )
+ {
+ SMDS_ElemIteratorPtr faceIt = (*corner)->GetInverseElementIterator( SMDSAbs_Face );
+ while ( faceIt->more() )
+ {
+ const SMDS_MeshElement* face = faceIt->next();
+ if ( !cornerFaces.insert( face ).second )
+ continue; // already loaded block side
+
+ if ( !isQuadrangle( face ))
+ return error("Non-quadrangle elements in the input mesh");
+
+ if ( _allSides.empty() || !_allSides.back()._grid.empty() )
+ _allSides.push_back( _BlockSide() );
+
+ _BlockSide& side = _allSides.back();
+ if ( !fillSide( side, face, *corner ) )
+ {
+ if ( !_error.empty() )
+ return false;
+ }
+ else
+ {
+ for ( int isXMax = 0; isXMax < 2; ++isXMax )
+ for ( int isYMax = 0; isYMax < 2; ++isYMax )
+ {
+ const SMDS_MeshNode* nCorner = side.getCornerNode(isXMax,isYMax );
+ corners.push_back( nCorner );
+ cornerFaces.insert( side.getCornerFace( nCorner ));
+ }
+ for ( int e = 0; e < int(NB_QUAD_SIDES); ++e )
+ _edge2sides[ side.getEdge( (EQuadEdge) e ) ].insert( &side );
+
+ nbFacesOnSides += side.getNbFaces();
+ }
+ }
+ ++corner;
+
+ // find block sides of other domains if any
+ if ( corner == corners.end() && nbFacesOnSides < mesh.NbQuadrangles() )
+ {
+ while ( nIt->more() )
+ {
+ nCorner = nIt->next();
+ if ( isCornerNode( nCorner ))
+ corner = corners.insert( corner, nCorner );
+ }
+ nbFacesOnSides = mesh.NbQuadrangles();
+ }
+ }
+
+ if ( _allSides.empty() )
+ return BAD_MESH_ERR;
+ if ( _allSides.back()._grid.empty() )
+ _allSides.pop_back();
+ _DUMP_("Nb detected sides "<< _allSides.size());
+
+ // ---------------------------
+ // Organize sides into blocks
+ // ---------------------------
+
+ // analyse sharing of sides by blocks and sort sides by nb of adjacent sides
+ int nbBlockSides = 0; // total nb of block sides taking into account their sharing
+ multimap<int, _BlockSide* > sortedSides;
+ {
+ list < _BlockSide >::iterator sideIt = _allSides.begin();
+ for ( ; sideIt != _allSides.end(); ++sideIt )
+ {
+ _BlockSide& side = *sideIt;
+ bool isSharedSide = true;
+ int nbAdjacent = 0;
+ for ( int e = 0; e < int(NB_QUAD_SIDES) && isSharedSide; ++e )
+ {
+ int nbAdj = _edge2sides[ side.getEdge( (EQuadEdge) e ) ].size();
+ nbAdjacent += nbAdj;
+ isSharedSide = ( nbAdj > 2 );
+ }
+ side._nbBlocksFound = 0;
+ side._nbBlocksExpected = isSharedSide ? 2 : 1;
+ nbBlockSides += side._nbBlocksExpected;
+ sortedSides.insert( make_pair( nbAdjacent, & side ));
+ }
+ }
+
+ // find sides of each block
+ int nbBlocks = 0;
+ while ( nbBlockSides >= 6 )
+ {
+ // get any side not bound to all blocks it belongs to
+ multimap<int, _BlockSide*>::iterator i_side = sortedSides.begin();
+ while ( i_side != sortedSides.end() && i_side->second->isBound())
+ ++i_side;
+
+ // start searching for block sides from the got side
+ bool ok = true;
+ if ( _blocks.empty() || _blocks.back()._side[B_FRONT] )
+ _blocks.resize( _blocks.size() + 1 );
+
+ _Block& block = _blocks.back();
+ block.setSide( B_FRONT, i_side->second );
+ setSideBoundToBlock( *i_side->second );
+ nbBlockSides--;
+
+ // edges of adjacent sides of B_FRONT corresponding to front's edges
+ EQuadEdge edgeOfFront[4] = { Q_BOTTOM, Q_RIGHT, Q_TOP, Q_LEFT };
+ EQuadEdge edgeOfAdj [4] = { Q_BOTTOM, Q_LEFT, Q_BOTTOM, Q_LEFT };
+ // first find all sides detectable w/o advanced analysis,
+ // then repeat the search, which then may pass without advanced analysis
+ set< _BlockSide* > sidesAround;
+ for ( int advAnalys = 0; advAnalys < 2; ++advAnalys )
+ {
+ // try to find 4 sides adjacent to a FRONT side
+ for ( int i = 0; (ok || !advAnalys) && i < NB_QUAD_SIDES; ++i )
+ if ( !block._side[i] )
+ ok = block.setSide( i, findBlockSide( B_FRONT, edgeOfFront[i], edgeOfAdj[i],
+ advAnalys, sidesAround));
+ // try to find a BACK side by a TOP one
+ if ( ok || !advAnalys)
+ if ( !block._side[B_BACK] && block._side[B_TOP] )
+ ok = block.setSide( B_BACK, findBlockSide( B_TOP, Q_TOP, Q_TOP,
+ advAnalys, sidesAround ));
+ if ( !advAnalys ) ok = true;
+ }
+ ok = block.isValid();
+ if ( ok )
+ {
+ // check if just found block is same as one of previously found blocks
+ bool isSame = false;
+ for ( int i = 1; i < _blocks.size() && !isSame; ++i )
+ isSame = ( block._corners == _blocks[i-1]._corners );
+ ok = !isSame;
+ }
+
+ // count the found sides
+ _DUMP_(endl << "** Block " << _blocks.size() << " valid: " << block.isValid());
+ for (int i = 0; i < NB_BLOCK_SIDES; ++i )
+ {
+ _DUMP_("\tSide "<< SBoxSides[i] <<" "<< block._side[ i ]._side);
+ if ( block._side[ i ] )
+ {
+ if ( ok && i != B_FRONT)
+ {
+ setSideBoundToBlock( *block._side[ i ]._side );
+ nbBlockSides--;
+ }
+ _DUMP_("\t corners "<<
+ block._side[ i ].cornerNode(0,0)->GetID() << ", " <<
+ block._side[ i ].cornerNode(1,0)->GetID() << ", " <<
+ block._side[ i ].cornerNode(1,1)->GetID() << ", " <<
+ block._side[ i ].cornerNode(0,1)->GetID() << ", "<<endl);
+ }
+ else
+ {
+ _DUMP_("\t not found"<<endl);
+ }
+ }
+ if ( !ok )
+ block.clear();
+ else
+ nbBlocks++;
+ }
+ _DUMP_("Nb found blocks "<< nbBlocks <<endl);
+
+ if ( nbBlocks == 0 && _error.empty() )
+ return BAD_MESH_ERR;
+
+ return nbBlocks;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Fill block side data starting from its corner quadrangle
+ */
+ //================================================================================
+
+ bool _Skin::fillSide( _BlockSide& side,
+ const SMDS_MeshElement* cornerQuad,
+ const SMDS_MeshNode* nCorner)
+ {
+ // Find out size of block side mesured in nodes and by the way find two rows
+ // of nodes in two directions.
+
+ int x, y, nbX, nbY;
+ const SMDS_MeshElement* firstQuad = cornerQuad;
+ {
+ // get a node on block edge
+ int iCorner = firstQuad->GetNodeIndex( nCorner );
+ const SMDS_MeshNode* nOnEdge = firstQuad->GetNode( (iCorner+1) % 4);
+
+ // find out size of block side
+ vector<const SMDS_MeshNode*> horRow1, horRow2, verRow1, verRow2;
+ if ( !fillRowsUntilCorner( firstQuad, nCorner, nOnEdge, horRow1, horRow2, true ) ||
+ !fillRowsUntilCorner( firstQuad, nCorner, nOnEdge, verRow1, verRow2, false ))
+ return false;
+ nbX = horRow1.size(), nbY = verRow1.size();
+
+ // store found nodes
+ side._index._xSize = horRow1.size();
+ side._index._ySize = verRow1.size();
+ side._grid.resize( side._index.size(), NULL );
+
+ for ( x = 0; x < horRow1.size(); ++x )
+ {
+ side.setNode( x, 0, horRow1[x] );
+ side.setNode( x, 1, horRow2[x] );
+ }
+ for ( y = 0; y < verRow1.size(); ++y )
+ {
+ side.setNode( 0, y, verRow1[y] );
+ side.setNode( 1, y, verRow2[y] );
+ }
+ }
+ // Find the rest nodes
+
+ y = 1; // y of the row to fill
+ TIDSortedElemSet emptySet, avoidSet;
+ while ( ++y < nbY )
+ {
+ // get next firstQuad in the next row of quadrangles
+ //
+ // n2up
+ // o---o <- y row
+ // | |
+ // o---o o o o o <- found nodes
+ //n1down n2down
+ //
+ int i1down, i2down, i2up;
+ const SMDS_MeshNode* n1down = side.getNode( 0, y-1 );
+ const SMDS_MeshNode* n2down = side.getNode( 1, y-1 );
+ avoidSet.clear(); avoidSet.insert( firstQuad );
+ firstQuad = SMESH_MeshEditor::FindFaceInSet( n1down, n2down, emptySet, avoidSet,
+ &i1down, &i2down);
+ if ( !isQuadrangle( firstQuad ))
+ return BAD_MESH_ERR;
+
+ const SMDS_MeshNode* n2up = oppositeNode( firstQuad, i1down );
+ avoidSet.clear(); avoidSet.insert( firstQuad );
+
+ // find the rest nodes in the y-th row by faces in the row
+
+ x = 1;
+ while ( ++x < nbX )
+ {
+ const SMDS_MeshElement* quad = SMESH_MeshEditor::FindFaceInSet( n2up, n2down, emptySet,
+ avoidSet, &i2up, &i2down);
+ if ( !isQuadrangle( quad ))
+ return BAD_MESH_ERR;
+
+ n2up = oppositeNode( quad, i2down );
+ n2down = oppositeNode( quad, i2up );
+ avoidSet.clear(); avoidSet.insert( quad );
+
+ side.setNode( x, y, n2up );
+ }
+ }
+
+ // check side validity
+ bool ok =
+ side.getCornerFace( side.getCornerNode( 0, 0 )) &&
+ side.getCornerFace( side.getCornerNode( 1, 0 )) &&
+ side.getCornerFace( side.getCornerNode( 0, 1 )) &&
+ side.getCornerFace( side.getCornerNode( 1, 1 ));
+
+ return ok;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return true if it's possible to make a loop over corner2Sides starting
+ * from the startSide
+ */
+ //================================================================================
+
+ bool isClosedChainOfSides( _BlockSide* startSide,
+ map< const SMDS_MeshNode*, list< _BlockSide* > > & corner2Sides )
+ {
+ // get start and end nodes
+ const SMDS_MeshNode *n1 = 0, *n2 = 0, *n;
+ for ( int y = 0; y < 2; ++y )
+ for ( int x = 0; x < 2; ++x )
+ {
+ n = startSide->getCornerNode(x,y);
+ if ( !corner2Sides.count( n )) continue;
+ if ( n1 )
+ n2 = n;
+ else
+ n1 = n;
+ }
+ if ( !n2 ) return false;
+
+ map< const SMDS_MeshNode*, list< _BlockSide* > >::iterator
+ c2sides = corner2Sides.find( n1 );
+ if ( c2sides == corner2Sides.end() ) return false;
+
+ int nbChainLinks = 1;
+ n = n1;
+ _BlockSide* prevSide = startSide;
+ while ( n != n2 )
+ {
+ // get the next side sharing n
+ list< _BlockSide* > & sides = c2sides->second;
+ _BlockSide* nextSide = ( sides.back() == prevSide ? sides.front() : sides.back() );
+ if ( nextSide == prevSide ) return false;
+
+ // find the next corner of the nextSide being in corner2Sides
+ n1 = n;
+ n = 0;
+ for ( int y = 0; y < 2 && !n; ++y )
+ for ( int x = 0; x < 2; ++x )
+ {
+ n = nextSide->getCornerNode(x,y);
+ c2sides = corner2Sides.find( n );
+ if ( n == n1 || c2sides == corner2Sides.end() )
+ n = 0;
+ else
+ break;
+ }
+ if ( !n ) return false;
+
+ prevSide = nextSide;
+ nbChainLinks++;
+ }
+
+ return ( n == n2 && nbChainLinks == NB_QUAD_SIDES );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Try to find a block side adjacent to the given side by given edge
+ */
+ //================================================================================
+
+ _OrientedBlockSide _Skin::findBlockSide( EBoxSides startBlockSide,
+ EQuadEdge sharedSideEdge1,
+ EQuadEdge sharedSideEdge2,
+ bool withGeometricAnalysis,
+ set< _BlockSide* >& sidesAround)
+ {
+ _Block& block = _blocks.back();
+ _OrientedBlockSide& side1 = block._side[ startBlockSide ];
+
+ // get corner nodes of the given block edge
+ SMESH_OrientedLink edge = side1.edge( sharedSideEdge1 );
+ const SMDS_MeshNode* n1 = edge.node1();
+ const SMDS_MeshNode* n2 = edge.node2();
+ if ( edge._reversed ) swap( n1, n2 );
+
+ // find all sides sharing both nodes n1 and n2
+ set< _BlockSide* > sidesOnEdge = _edge2sides[ edge ]; // copy a set
+
+ // exclude loaded sides of block from sidesOnEdge
+ for (int i = 0; i < NB_BLOCK_SIDES; ++i )
+ if ( block._side[ i ] )
+ sidesOnEdge.erase( block._side[ i ]._side );
+
+ int nbSidesOnEdge = sidesOnEdge.size();
+ _DUMP_("nbSidesOnEdge "<< nbSidesOnEdge << " " << n1->GetID() << "-" << n2->GetID() );
+ if ( nbSidesOnEdge == 0 )
+ return 0;
+
+ _BlockSide* foundSide = 0;
+ if ( nbSidesOnEdge == 1 )
+ {
+ foundSide = *sidesOnEdge.begin();
+ }
+ else
+ {
+ set< _BlockSide* >::iterator sideIt = sidesOnEdge.begin();
+ int nbLoadedSides = block.nbSides();
+ if ( nbLoadedSides > 1 )
+ {
+ // Find the side having more than 2 corners common with already loaded sides
+ for (; !foundSide && sideIt != sidesOnEdge.end(); ++sideIt )
+ {
+ _BlockSide* sideI = *sideIt;
+ int nbCommonCorners =
+ block._corners.count( sideI->getCornerNode(0,0)) +
+ block._corners.count( sideI->getCornerNode(1,0)) +
+ block._corners.count( sideI->getCornerNode(0,1)) +
+ block._corners.count( sideI->getCornerNode(1,1));
+ if ( nbCommonCorners > 2 )
+ foundSide = sideI;
+ }
+ }
+
+ if ( !foundSide )
+ {
+ if ( !withGeometricAnalysis )
+ {
+ sidesAround.insert( sidesOnEdge.begin(), sidesOnEdge.end() );
+ return 0;
+ }
+ if ( nbLoadedSides == 1 )
+ {
+ // Issue 0021529. There are at least 2 sides by each edge and
+ // position of block gravity center is undefined.
+ // Find a side starting from which we can walk around the startBlockSide
+
+ // fill in corner2Sides
+ map< const SMDS_MeshNode*, list< _BlockSide* > > corner2Sides;
+ for ( sideIt = sidesAround.begin(); sideIt != sidesAround.end(); ++sideIt )
+ {
+ _BlockSide* sideI = *sideIt;
+ corner2Sides[ sideI->getCornerNode(0,0) ].push_back( sideI );
+ corner2Sides[ sideI->getCornerNode(1,0) ].push_back( sideI );
+ corner2Sides[ sideI->getCornerNode(0,1) ].push_back( sideI );
+ corner2Sides[ sideI->getCornerNode(1,1) ].push_back( sideI );
+ }
+ // remove corners of startBlockSide from corner2Sides
+ set<const SMDS_MeshNode*>::iterator nIt = block._corners.begin();
+ for ( ; nIt != block._corners.end(); ++nIt )
+ corner2Sides.erase( *nIt );
+
+ // select a side
+ for ( sideIt = sidesOnEdge.begin(); sideIt != sidesOnEdge.end(); ++sideIt )
+ {
+ if ( isClosedChainOfSides( *sideIt, corner2Sides ))
+ {
+ foundSide = *sideIt;
+ break;
+ }
+ }
+ if ( !foundSide )
+ return 0;
+ }
+ else
+ {
+ // Select one of found sides most close to startBlockSide
+
+ gp_XYZ p1 ( n1->X(),n1->Y(),n1->Z()), p2 (n2->X(),n2->Y(),n2->Z());
+ gp_Vec p1p2( p1, p2 );
+
+ const SMDS_MeshElement* face1 = side1->getCornerFace( n1 );
+ gp_XYZ p1Op = SMESH_TNodeXYZ( oppositeNode( face1, face1->GetNodeIndex(n1)));
+ gp_Vec side1Dir( p1, p1Op );
+ gp_Ax2 pln( p1, p1p2, side1Dir ); // plane with normal p1p2 and X dir side1Dir
+ _DUMP_(" Select adjacent for "<< side1._side << " - side dir ("
+ << side1Dir.X() << ", " << side1Dir.Y() << ", " << side1Dir.Z() << ")" );
+
+ map < double , _BlockSide* > angleOfSide;
+ for (sideIt = sidesOnEdge.begin(); sideIt != sidesOnEdge.end(); ++sideIt )
+ {
+ _BlockSide* sideI = *sideIt;
+ const SMDS_MeshElement* faceI = sideI->getCornerFace( n1 );
+ gp_XYZ p1Op = SMESH_TNodeXYZ( oppositeNode( faceI, faceI->GetNodeIndex(n1)));
+ gp_Vec sideIDir( p1, p1Op );
+ // compute angle of (sideIDir projection to pln) and (X dir of pln)
+ gp_Vec2d sideIDirProj( sideIDir * pln.XDirection(), sideIDir * pln.YDirection());
+ double angle = sideIDirProj.Angle( gp::DX2d() );
+ if ( angle < 0 ) angle += 2. * M_PI; // angle [0-2*PI]
+ angleOfSide.insert( make_pair( angle, sideI ));
+ _DUMP_(" "<< sideI << " - side dir ("
+ << sideIDir.X() << ", " << sideIDir.Y() << ", " << sideIDir.Z() << ")"
+ << " angle " << angle);
+ }
+
+ gp_XYZ gc(0,0,0); // gravity center of already loaded block sides
+ for (int i = 0; i < NB_BLOCK_SIDES; ++i )
+ if ( block._side[ i ] )
+ gc += block._side[ i ]._side->getGC();
+ gc /= nbLoadedSides;
+
+ gp_Vec gcDir( p1, gc );
+ gp_Vec2d gcDirProj( gcDir * pln.XDirection(), gcDir * pln.YDirection());
+ double gcAngle = gcDirProj.Angle( gp::DX2d() );
+ foundSide = gcAngle < 0 ? angleOfSide.rbegin()->second : angleOfSide.begin()->second;
+ }
+ }
+ _DUMP_(" selected "<< foundSide );
+ }
+
+ // Orient the found side correctly
+
+ // corners of found side corresponding to nodes n1 and n2
+ bool xMax1, yMax1, xMax2, yMax2;
+ if ( !getEdgeEnds( sharedSideEdge2, xMax1, yMax1, xMax2, yMax2 ))
+ return error(SMESH_Comment("Internal error at ")<<__FILE__<<":"<<__LINE__),
+ _OrientedBlockSide(0);
+
+ for ( int ori = 0; ori < _OrientedIndexer::MAX_ORI+1; ++ori )
+ {
+ _OrientedBlockSide orientedSide( foundSide, ori );
+ const SMDS_MeshNode* n12 = orientedSide.cornerNode( xMax1, yMax1);
+ const SMDS_MeshNode* n22 = orientedSide.cornerNode( xMax2, yMax2);
+ if ( n1 == n12 && n2 == n22 )
+ return orientedSide;
+ }
+ error(SMESH_Comment("Failed to orient a block side found by edge ")<<sharedSideEdge1
+ << " of side " << startBlockSide
+ << " of block " << _blocks.size());
+ return 0;
+ }
+
+ //================================================================================
+ /*!
+ * \brief: Fill rows (which are actually columns,if !alongN1N2) of nodes starting
+ * from the given quadrangle until another block corner encounters.
+ * n1 and n2 are at bottom of quad, n1 is at block corner.
+ */
+ //================================================================================
+
+ bool _Skin::fillRowsUntilCorner(const SMDS_MeshElement* quad,
+ const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2,
+ vector<const SMDS_MeshNode*>& row1,
+ vector<const SMDS_MeshNode*>& row2,
+ const bool alongN1N2 )
+ {
+ const SMDS_MeshNode* corner1 = n1;
+
+ // Store nodes of quad in the rows and find new n1 and n2 to get
+ // the next face so that new n2 is on block edge
+ int i1 = quad->GetNodeIndex( n1 );
+ int i2 = quad->GetNodeIndex( n2 );
+ row1.clear(); row2.clear();
+ row1.push_back( n1 );
+ if ( alongN1N2 )
+ {
+ row1.push_back( n2 );
+ row2.push_back( oppositeNode( quad, i2 ));
+ row2.push_back( n1 = oppositeNode( quad, i1 ));
+ }
+ else
+ {
+ row2.push_back( n2 );
+ row1.push_back( n2 = oppositeNode( quad, i2 ));
+ row2.push_back( n1 = oppositeNode( quad, i1 ));
+ }
+
+ if ( isCornerNode( row1[1] ))
+ return true;
+
+ // Find the rest nodes
+ TIDSortedElemSet emptySet, avoidSet;
+ while ( !isCornerNode( n2 ) )
+ {
+ avoidSet.clear(); avoidSet.insert( quad );
+ quad = SMESH_MeshEditor::FindFaceInSet( n1, n2, emptySet, avoidSet, &i1, &i2 );
+ if ( !isQuadrangle( quad ))
+ return BAD_MESH_ERR;
+
+ row1.push_back( n2 = oppositeNode( quad, i1 ));
+ row2.push_back( n1 = oppositeNode( quad, i2 ));
+ }
+ return n1 != corner1;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Return a corner face by a corner node
+ */
+ //================================================================================
+
+ const SMDS_MeshElement* _BlockSide::getCornerFace(const SMDS_MeshNode* cornerNode) const
+ {
+ int x, y, isXMax, isYMax, found = 0;
+ for ( isXMax = 0; isXMax < 2; ++isXMax )
+ {
+ for ( isYMax = 0; isYMax < 2; ++isYMax )
+ {
+ x = isXMax ? _index._xSize-1 : 0;
+ y = isYMax ? _index._ySize-1 : 0;
+ found = ( getNode(x,y) == cornerNode );
+ if ( found ) break;
+ }
+ if ( found ) break;
+ }
+ if ( !found ) return 0;
+ int dx = isXMax ? -1 : +1;
+ int dy = isYMax ? -1 : +1;
+ const SMDS_MeshNode* n1 = getNode(x,y);
+ const SMDS_MeshNode* n2 = getNode(x+dx,y);
+ const SMDS_MeshNode* n3 = getNode(x,y+dy);
+ const SMDS_MeshNode* n4 = getNode(x+dx,y+dy);
+ return SMDS_Mesh::FindFace(n1, n2, n3, n4 );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Checks own validity
+ */
+ //================================================================================
+
+ bool _Block::isValid() const
+ {
+ bool ok = ( nbSides() == 6 );
+
+ // check only corners depending on side selection
+ EBoxSides adjacent[4] = { B_BOTTOM, B_RIGHT, B_TOP, B_LEFT };
+ EQuadEdge edgeAdj [4] = { Q_TOP, Q_RIGHT, Q_TOP, Q_RIGHT };
+ EQuadEdge edgeBack[4] = { Q_BOTTOM, Q_RIGHT, Q_TOP, Q_LEFT };
+
+ for ( int i=0; ok && i < NB_QUAD_SIDES; ++i )
+ {
+ SMESH_OrientedLink eBack = _side[ B_BACK ].edge( edgeBack[i] );
+ SMESH_OrientedLink eAdja = _side[ adjacent[i] ].edge( edgeAdj[i] );
+ ok = ( eBack == eAdja );
+ }
+ return ok;
+ }
+
+} // namespace
+
+
+
+
+
+HEXA_NS::Hexa* _block2Hexa( const _Block& block,
+ HEXA_NS::Document* doc,
+ std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> vertexNode )
+{
+ const SMDS_MeshNode* n000 = block.getSide(B_BOTTOM).cornerNode( 0, 0 );
+ const SMDS_MeshNode* n100 = block.getSide(B_BOTTOM).cornerNode( 1, 0 );
+ const SMDS_MeshNode* n010 = block.getSide(B_BOTTOM).cornerNode( 0, 1 );
+ const SMDS_MeshNode* n110 = block.getSide(B_BOTTOM).cornerNode( 1, 1 );
+ const SMDS_MeshNode* n001 = block.getSide(B_TOP).cornerNode( 0, 0 );
+ const SMDS_MeshNode* n101 = block.getSide(B_TOP).cornerNode( 1, 0 );
+ const SMDS_MeshNode* n011 = block.getSide(B_TOP).cornerNode( 0, 1 );
+ const SMDS_MeshNode* n111 = block.getSide(B_TOP).cornerNode( 1, 1 );
+
+ list<const SMDS_MeshNode* > nodeFromBlock;
+ nodeFromBlock.push_back(n000);
+ nodeFromBlock.push_back(n100);
+ nodeFromBlock.push_back(n010);
+ nodeFromBlock.push_back(n110);
+ nodeFromBlock.push_back(n001);
+ nodeFromBlock.push_back(n101);
+ nodeFromBlock.push_back(n011);
+ nodeFromBlock.push_back(n111);
+ nodeFromBlock.sort();
+
+
+ HEXA_NS::Hexa* hexa = NULL;
+ int nHexa = doc->countUsedHexa();
+ for (int j=0; j <nHexa; ++j ){
+ hexa = doc->getUsedHexa(j);
+ list<const SMDS_MeshNode* > nodeFromHexa;
+ int nVx = hexa->countVertex();
+ for ( int i=0; i <nVx; ++i ){
+ HEXA_NS::Vertex* v = hexa->getVertex(i);
+ const SMDS_MeshNode* n = vertexNode[v];
+ nodeFromHexa.push_back(n);
+ }
+ nodeFromHexa.sort();
+
+ if ( nodeFromBlock == nodeFromHexa ){
+// std::cout << "OK block match hexa "<< hexa <<" id = "<<hexa->getId()<<std::endl;
+ return hexa;
+ } /*else {
+ std::cout << "KO block does not match hexa "<< hexa <<" id = "<<hexa->getId()<<std::endl;
+ }*/
+ }
+ return NULL;
+}
+
+
+
+
+
+
+
+
+//=======================================================================
+//function : SMESH_HexaFromSkin_3D
+//purpose :
+//=======================================================================
+
+// SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen)
+// :SMESH_3D_Algo(hypId, studyId, gen)
+// {
+// MESSAGE("SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D");
+// _name = "HexaFromSkin_3D";
+// }
+
+SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen, HEXA_NS::Document* doc)
+ :SMESH_3D_Algo(hypId, studyId, gen),
+ _doc( doc )
+{
+ if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::SMESH_HexaFromSkin_3D");
+ _name = "HexaFromSkin_3D";
+}
+
+
+SMESH_HexaFromSkin_3D::~SMESH_HexaFromSkin_3D()
+{
+ if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::~SMESH_HexaFromSkin_3D");
+}
+
+//================================================================================
+/*!
+ * \brief Main method, which generates hexaheda
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper)
+{
+ _Skin skin;
+ int nbBlocks = skin.findBlocks(aMesh);
+ if ( nbBlocks == 0 )
+ return error( skin.error());
+
+ vector< vector< const SMDS_MeshNode* > > columns;
+ int x, xSize, y, ySize, z, zSize;
+ _Indexer colIndex;
+
+ for ( int i = 0; i < nbBlocks; ++i )
+ {
+ const _Block& block = skin.getBlock( i );
+
+ // ------------------------------------------
+ // Fill columns of nodes with existing nodes
+ // ------------------------------------------
+
+ xSize = block.getSide(B_BOTTOM).getHoriSize();
+ ySize = block.getSide(B_BOTTOM).getVertSize();
+ zSize = block.getSide(B_FRONT ).getVertSize();
+ int X = xSize - 1, Y = ySize - 1, Z = zSize - 1;
+ colIndex = _Indexer( xSize, ySize );
+ columns.resize( colIndex.size() );
+
+ // fill node columns by front and back box sides
+ for ( x = 0; x < xSize; ++x ) {
+ vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( x, 0 )];
+ vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( x, Y )];
+ column0.resize( zSize );
+ column1.resize( zSize );
+ for ( z = 0; z < zSize; ++z ) {
+ column0[ z ] = block.getSide(B_FRONT).node( x, z );
+ column1[ z ] = block.getSide(B_BACK) .node( x, z );
+ }
+ }
+ // fill node columns by left and right box sides
+ for ( y = 1; y < ySize-1; ++y ) {
+ vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( 0, y )];
+ vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( X, y )];
+ column0.resize( zSize );
+ column1.resize( zSize );
+ for ( z = 0; z < zSize; ++z ) {
+ column0[ z ] = block.getSide(B_LEFT) .node( y, z );
+ column1[ z ] = block.getSide(B_RIGHT).node( y, z );
+ }
+ }
+ // get nodes from top and bottom box sides
+ for ( x = 1; x < xSize-1; ++x ) {
+ for ( y = 1; y < ySize-1; ++y ) {
+ vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+ column.resize( zSize );
+ column.front() = block.getSide(B_BOTTOM).node( x, y );
+ column.back() = block.getSide(B_TOP) .node( x, y );
+ }
+ }
+
+ // ----------------------------
+ // Add internal nodes of a box
+ // ----------------------------
+ // projection points of internal nodes on box sub-shapes by which
+ // coordinates of internal nodes are computed
+ vector<gp_XYZ> pointOnShape( SMESH_Block::ID_Shell );
+
+ // projections on vertices are constant
+ pointOnShape[ SMESH_Block::ID_V000 ] = block.getSide(B_BOTTOM).xyz( 0, 0 );
+ pointOnShape[ SMESH_Block::ID_V100 ] = block.getSide(B_BOTTOM).xyz( X, 0 );
+ pointOnShape[ SMESH_Block::ID_V010 ] = block.getSide(B_BOTTOM).xyz( 0, Y );
+ pointOnShape[ SMESH_Block::ID_V110 ] = block.getSide(B_BOTTOM).xyz( X, Y );
+ pointOnShape[ SMESH_Block::ID_V001 ] = block.getSide(B_TOP).xyz( 0, 0 );
+ pointOnShape[ SMESH_Block::ID_V101 ] = block.getSide(B_TOP).xyz( X, 0 );
+ pointOnShape[ SMESH_Block::ID_V011 ] = block.getSide(B_TOP).xyz( 0, Y );
+ pointOnShape[ SMESH_Block::ID_V111 ] = block.getSide(B_TOP).xyz( X, Y );
+
+ for ( x = 1; x < xSize-1; ++x )
+ {
+ gp_XYZ params; // normalized parameters of internal node within a unit box
+ params.SetCoord( 1, x / double(X) );
+ for ( y = 1; y < ySize-1; ++y )
+ {
+ params.SetCoord( 2, y / double(Y) );
+ // column to fill during z loop
+ vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+ // projections on horizontal edges
+ pointOnShape[ SMESH_Block::ID_Ex00 ] = block.getSide(B_BOTTOM).xyz( x, 0 );
+ pointOnShape[ SMESH_Block::ID_Ex10 ] = block.getSide(B_BOTTOM).xyz( x, Y );
+ pointOnShape[ SMESH_Block::ID_E0y0 ] = block.getSide(B_BOTTOM).xyz( 0, y );
+ pointOnShape[ SMESH_Block::ID_E1y0 ] = block.getSide(B_BOTTOM).xyz( X, y );
+ pointOnShape[ SMESH_Block::ID_Ex01 ] = block.getSide(B_TOP).xyz( x, 0 );
+ pointOnShape[ SMESH_Block::ID_Ex11 ] = block.getSide(B_TOP).xyz( x, Y );
+ pointOnShape[ SMESH_Block::ID_E0y1 ] = block.getSide(B_TOP).xyz( 0, y );
+ pointOnShape[ SMESH_Block::ID_E1y1 ] = block.getSide(B_TOP).xyz( X, y );
+ // projections on horizontal sides
+ pointOnShape[ SMESH_Block::ID_Fxy0 ] = block.getSide(B_BOTTOM).xyz( x, y );
+ pointOnShape[ SMESH_Block::ID_Fxy1 ] = block.getSide(B_TOP) .xyz( x, y );
+ for ( z = 1; z < zSize-1; ++z ) // z loop
+ {
+ params.SetCoord( 3, z / double(Z) );
+ // projections on vertical edges
+ pointOnShape[ SMESH_Block::ID_E00z ] = block.getSide(B_FRONT).xyz( 0, z );
+ pointOnShape[ SMESH_Block::ID_E10z ] = block.getSide(B_FRONT).xyz( X, z );
+ pointOnShape[ SMESH_Block::ID_E01z ] = block.getSide(B_BACK).xyz( 0, z );
+ pointOnShape[ SMESH_Block::ID_E11z ] = block.getSide(B_BACK).xyz( X, z );
+ // projections on vertical sides
+ pointOnShape[ SMESH_Block::ID_Fx0z ] = block.getSide(B_FRONT).xyz( x, z );
+ pointOnShape[ SMESH_Block::ID_Fx1z ] = block.getSide(B_BACK) .xyz( x, z );
+ pointOnShape[ SMESH_Block::ID_F0yz ] = block.getSide(B_LEFT) .xyz( y, z );
+ pointOnShape[ SMESH_Block::ID_F1yz ] = block.getSide(B_RIGHT).xyz( y, z );
+
+ // compute internal node coordinates
+ gp_XYZ coords;
+ SMESH_Block::ShellPoint( params, pointOnShape, coords );
+ column[ z ] = aHelper->AddNode( coords.X(), coords.Y(), coords.Z() );
+
+#ifdef DEB_GRID
+ // debug
+ //cout << "----------------------------------------------------------------------"<<endl;
+ //for ( int id = SMESH_Block::ID_V000; id < SMESH_Block::ID_Shell; ++id)
+ //{
+ // gp_XYZ p = pointOnShape[ id ];
+ // SMESH_Block::DumpShapeID( id,cout)<<" ( "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;
+ //}
+ //cout << "Params: ( "<< params.X()<<", "<<params.Y()<<", "<<params.Z()<<" )"<<endl;
+ //cout << "coords: ( "<< coords.X()<<", "<<coords.Y()<<", "<<coords.Z()<<" )"<<endl;
+#endif
+ }
+ }
+ }
+ // ----------------
+ // Add hexahedrons
+ // ----------------
+
+ // find out orientation by a least distorted hexahedron (issue 0020855);
+ // the last is defined by evaluating sum of face normals of 8 corner hexahedrons
+ double badness = numeric_limits<double>::max();
+ bool isForw = true;
+ for ( int xMax = 0; xMax < 2; ++xMax )
+ for ( int yMax = 0; yMax < 2; ++yMax )
+ for ( int zMax = 0; zMax < 2; ++zMax )
+ {
+ x = xMax ? xSize-1 : 1;
+ y = yMax ? ySize-1 : 1;
+ z = zMax ? zSize-1 : 1;
+ vector< const SMDS_MeshNode* >& col00 = columns[ colIndex( x-1, y-1 )];
+ vector< const SMDS_MeshNode* >& col10 = columns[ colIndex( x , y-1 )];
+ vector< const SMDS_MeshNode* >& col01 = columns[ colIndex( x-1, y )];
+ vector< const SMDS_MeshNode* >& col11 = columns[ colIndex( x , y )];
+
+ const SMDS_MeshNode* n000 = col00[z-1];
+ const SMDS_MeshNode* n100 = col10[z-1];
+ const SMDS_MeshNode* n010 = col01[z-1];
+ const SMDS_MeshNode* n110 = col11[z-1];
+ const SMDS_MeshNode* n001 = col00[z];
+ const SMDS_MeshNode* n101 = col10[z];
+ const SMDS_MeshNode* n011 = col01[z];
+ const SMDS_MeshNode* n111 = col11[z];
+ SMDS_VolumeOfNodes probeVolume (n000,n010,n110,n100,
+ n001,n011,n111,n101);
+ SMDS_VolumeTool volTool( &probeVolume );
+ double Nx=0.,Ny=0.,Nz=0.;
+ for ( int iFace = 0; iFace < volTool.NbFaces(); ++iFace )
+ {
+ double nx,ny,nz;
+ volTool.GetFaceNormal( iFace, nx,ny,nz );
+ Nx += nx;
+ Ny += ny;
+ Nz += nz;
+ }
+ double quality = Nx*Nx + Ny*Ny + Nz*Nz;
+ if ( quality < badness )
+ {
+ badness = quality;
+ isForw = volTool.IsForward();
+ }
+ }
+
+ // add elements
+ for ( x = 0; x < xSize-1; ++x ) {
+ for ( y = 0; y < ySize-1; ++y ) {
+ vector< const SMDS_MeshNode* >& col00 = columns[ colIndex( x, y )];
+ vector< const SMDS_MeshNode* >& col10 = columns[ colIndex( x+1, y )];
+ vector< const SMDS_MeshNode* >& col01 = columns[ colIndex( x, y+1 )];
+ vector< const SMDS_MeshNode* >& col11 = columns[ colIndex( x+1, y+1 )];
+ // bottom face normal of a hexa mush point outside the volume
+ if ( isForw )
+ for ( z = 0; z < zSize-1; ++z )
+ aHelper->AddVolume(col00[z], col01[z], col11[z], col10[z],
+ col00[z+1], col01[z+1], col11[z+1], col10[z+1]);
+ else
+ for ( z = 0; z < zSize-1; ++z )
+ aHelper->AddVolume(col00[z], col10[z], col11[z], col01[z],
+ col00[z+1], col10[z+1], col11[z+1], col01[z+1]);
+ }
+ }
+ } // loop on blocks
+
+ return true;
+}
+
+
+//================================================================================
+/*!
+ * \brief Main method, which generates hexaheda
+ */
+//================================================================================
+bool SMESH_HexaFromSkin_3D::Compute( SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper,
+ std::map<HEXA_NS::Hexa*, SMESH_HexaBlocks::SMESHVolumes>& volumesOnHexa,
+ std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> vertexNode )
+ {
+ if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::Compute BEGIN");
+ _Skin skin;
+ int nbBlocks = skin.findBlocks(aMesh);
+ if ( nbBlocks == 0 )
+ return error( skin.error());
+
+ vector< vector< const SMDS_MeshNode* > > columns;
+ int x, xSize, y, ySize, z, zSize;
+ _Indexer colIndex;
+
+ for ( int i = 0; i < nbBlocks; ++i )
+ {
+ const _Block& block = skin.getBlock( i );
+
+ // ------------------------------------------
+ // Fill columns of nodes with existing nodes
+ // ------------------------------------------
+
+ xSize = block.getSide(B_BOTTOM).getHoriSize();
+ ySize = block.getSide(B_BOTTOM).getVertSize();
+ zSize = block.getSide(B_FRONT ).getVertSize();
+ int X = xSize - 1, Y = ySize - 1, Z = zSize - 1;
+ colIndex = _Indexer( xSize, ySize );
+ columns.resize( colIndex.size() );
+
+ // fill node columns by front and back box sides
+ for ( x = 0; x < xSize; ++x ) {
+ vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( x, 0 )];
+ vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( x, Y )];
+ column0.resize( zSize );
+ column1.resize( zSize );
+ for ( z = 0; z < zSize; ++z ) {
+ column0[ z ] = block.getSide(B_FRONT).node( x, z );
+ column1[ z ] = block.getSide(B_BACK) .node( x, z );
+ }
+ }
+ // fill node columns by left and right box sides
+ for ( y = 1; y < ySize-1; ++y ) {
+ vector< const SMDS_MeshNode* >& column0 = columns[ colIndex( 0, y )];
+ vector< const SMDS_MeshNode* >& column1 = columns[ colIndex( X, y )];
+ column0.resize( zSize );
+ column1.resize( zSize );
+ for ( z = 0; z < zSize; ++z ) {
+ column0[ z ] = block.getSide(B_LEFT) .node( y, z );
+ column1[ z ] = block.getSide(B_RIGHT).node( y, z );
+ }
+ }
+ // get nodes from top and bottom box sides
+ for ( x = 1; x < xSize-1; ++x ) {
+ for ( y = 1; y < ySize-1; ++y ) {
+ vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+ column.resize( zSize );
+ column.front() = block.getSide(B_BOTTOM).node( x, y );
+ column.back() = block.getSide(B_TOP) .node( x, y );
+ }
+ }
+
+ // ----------------------------
+ // Add internal nodes of a box
+ // ----------------------------
+ // projection points of internal nodes on box subshapes by which
+ // coordinates of internal nodes are computed
+ vector<gp_XYZ> pointOnShape( SMESH_Block::ID_Shell );
+
+ // projections on vertices are constant
+ pointOnShape[ SMESH_Block::ID_V000 ] = block.getSide(B_BOTTOM).xyz( 0, 0 );
+ pointOnShape[ SMESH_Block::ID_V100 ] = block.getSide(B_BOTTOM).xyz( X, 0 );
+ pointOnShape[ SMESH_Block::ID_V010 ] = block.getSide(B_BOTTOM).xyz( 0, Y );
+ pointOnShape[ SMESH_Block::ID_V110 ] = block.getSide(B_BOTTOM).xyz( X, Y );
+ pointOnShape[ SMESH_Block::ID_V001 ] = block.getSide(B_TOP).xyz( 0, 0 );
+ pointOnShape[ SMESH_Block::ID_V101 ] = block.getSide(B_TOP).xyz( X, 0 );
+ pointOnShape[ SMESH_Block::ID_V011 ] = block.getSide(B_TOP).xyz( 0, Y );
+ pointOnShape[ SMESH_Block::ID_V111 ] = block.getSide(B_TOP).xyz( X, Y );
+
+ for ( x = 1; x < xSize-1; ++x )
+ {
+ gp_XYZ params; // normalized parameters of internal node within a unit box
+ params.SetCoord( 1, x / double(X) );
+ for ( y = 1; y < ySize-1; ++y )
+ {
+ params.SetCoord( 2, y / double(Y) );
+ // column to fill during z loop
+ vector< const SMDS_MeshNode* >& column = columns[ colIndex( x, y )];
+ // projections on horizontal edges
+ pointOnShape[ SMESH_Block::ID_Ex00 ] = block.getSide(B_BOTTOM).xyz( x, 0 );
+ pointOnShape[ SMESH_Block::ID_Ex10 ] = block.getSide(B_BOTTOM).xyz( x, Y );
+ pointOnShape[ SMESH_Block::ID_E0y0 ] = block.getSide(B_BOTTOM).xyz( 0, y );
+ pointOnShape[ SMESH_Block::ID_E1y0 ] = block.getSide(B_BOTTOM).xyz( X, y );
+ pointOnShape[ SMESH_Block::ID_Ex01 ] = block.getSide(B_TOP).xyz( x, 0 );
+ pointOnShape[ SMESH_Block::ID_Ex11 ] = block.getSide(B_TOP).xyz( x, Y );
+ pointOnShape[ SMESH_Block::ID_E0y1 ] = block.getSide(B_TOP).xyz( 0, y );
+ pointOnShape[ SMESH_Block::ID_E1y1 ] = block.getSide(B_TOP).xyz( X, y );
+ // projections on horizontal sides
+ pointOnShape[ SMESH_Block::ID_Fxy0 ] = block.getSide(B_BOTTOM).xyz( x, y );
+ pointOnShape[ SMESH_Block::ID_Fxy1 ] = block.getSide(B_TOP) .xyz( x, y );
+ for ( z = 1; z < zSize-1; ++z ) // z loop
+ {
+ params.SetCoord( 3, z / double(Z) );
+ // projections on vertical edges
+ pointOnShape[ SMESH_Block::ID_E00z ] = block.getSide(B_FRONT).xyz( 0, z );
+ pointOnShape[ SMESH_Block::ID_E10z ] = block.getSide(B_FRONT).xyz( X, z );
+ pointOnShape[ SMESH_Block::ID_E01z ] = block.getSide(B_BACK).xyz( 0, z );
+ pointOnShape[ SMESH_Block::ID_E11z ] = block.getSide(B_BACK).xyz( X, z );
+ // projections on vertical sides
+ pointOnShape[ SMESH_Block::ID_Fx0z ] = block.getSide(B_FRONT).xyz( x, z );
+ pointOnShape[ SMESH_Block::ID_Fx1z ] = block.getSide(B_BACK) .xyz( x, z );
+ pointOnShape[ SMESH_Block::ID_F0yz ] = block.getSide(B_LEFT) .xyz( y, z );
+ pointOnShape[ SMESH_Block::ID_F1yz ] = block.getSide(B_RIGHT).xyz( y, z );
+
+ // compute internal node coordinates
+ gp_XYZ coords;
+ SMESH_Block::ShellPoint( params, pointOnShape, coords );
+ column[ z ] = aHelper->AddNode( coords.X(), coords.Y(), coords.Z() );
+
+#ifdef DEB_GRID
+ // debug
+ //cout << "----------------------------------------------------------------------"<<endl;
+ //for ( int id = SMESH_Block::ID_V000; id < SMESH_Block::ID_Shell; ++id)
+ //{
+ // gp_XYZ p = pointOnShape[ id ];
+ // SMESH_Block::DumpShapeID( id,cout)<<" ( "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;
+ //}
+ //cout << "Params: ( "<< params.X()<<", "<<params.Y()<<", "<<params.Z()<<" )"<<endl;
+ //cout << "coords: ( "<< coords.X()<<", "<<coords.Y()<<", "<<coords.Z()<<" )"<<endl;
+#endif
+ }
+ }
+ }
+ // ----------------
+ // Add hexahedrons
+ // ----------------
+
+ // find out orientation
+ const SMDS_MeshNode* n000 = block.getSide(B_BOTTOM).cornerNode( 0, 0 );
+ const SMDS_MeshNode* n100 = block.getSide(B_BOTTOM).cornerNode( 1, 0 );
+ const SMDS_MeshNode* n010 = block.getSide(B_BOTTOM).cornerNode( 0, 1 );
+ const SMDS_MeshNode* n110 = block.getSide(B_BOTTOM).cornerNode( 1, 1 );
+ const SMDS_MeshNode* n001 = block.getSide(B_TOP).cornerNode( 0, 0 );
+ const SMDS_MeshNode* n101 = block.getSide(B_TOP).cornerNode( 1, 0 );
+ const SMDS_MeshNode* n011 = block.getSide(B_TOP).cornerNode( 0, 1 );
+ const SMDS_MeshNode* n111 = block.getSide(B_TOP).cornerNode( 1, 1 );
+ SMDS_VolumeOfNodes probeVolume (n000,n010,n110,n100,
+ n001,n011,n111,n101);
+ bool isForw = SMDS_VolumeTool( &probeVolume ).IsForward();
+
+ // add elements
+ SMESH_HexaBlocks::SMESHVolumes volumesOnBlock; //Groups creation
+
+ for ( x = 0; x < xSize-1; ++x ) {
+ for ( y = 0; y < ySize-1; ++y ) {
+ vector< const SMDS_MeshNode* >& col00 = columns[ colIndex( x, y )];
+ vector< const SMDS_MeshNode* >& col10 = columns[ colIndex( x+1, y )];
+ vector< const SMDS_MeshNode* >& col01 = columns[ colIndex( x, y+1 )];
+ vector< const SMDS_MeshNode* >& col11 = columns[ colIndex( x+1, y+1 )];
+ // bottom face normal of a hexa mush point outside the volume
+ if ( isForw )
+ for ( z = 0; z < zSize-1; ++z ){
+ SMDS_MeshVolume* newVolume =
+ aHelper->AddVolume(col00[z], col01[z], col11[z], col10[z],
+ col00[z+1], col01[z+1], col11[z+1], col10[z+1]);
+ volumesOnBlock.push_back( newVolume );
+ }
+ else
+ for ( z = 0; z < zSize-1; ++z ){
+ SMDS_MeshVolume* newVolume =
+ aHelper->AddVolume(col00[z], col10[z], col11[z], col01[z],
+ col00[z+1], col10[z+1], col11[z+1], col01[z+1]);
+ volumesOnBlock.push_back( newVolume );
+ }
+ }
+ }
+// std::cout << "block i = " << i << std::endl;
+ HEXA_NS::Hexa* currentHexa = _block2Hexa( block, _doc, vertexNode );
+ if ( currentHexa != NULL ){
+// std::cout<<"===== found ->"<<currentHexa<<" for block "<<i<<std::endl;
+ if ( volumesOnHexa.count(currentHexa)==0 ) {
+// std::cout<<"added!! "<<std::endl;
+ volumesOnHexa[currentHexa] = volumesOnBlock;
+ } else {
+// std::cout<<"already !! "<<std::endl;
+ }
+ } else {
+// std::cout<<"===== not found ->"<<currentHexa<<" for block "<<i<<std::endl;
+ }
+
+ } // loop on blocks
+
+ if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D::Compute END");
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Evaluate nb of hexa
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::Evaluate(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ MapShapeNbElems& aResMap)
+{
+ _Skin skin;
+ int nbBlocks = skin.findBlocks(aMesh);
+ if ( nbBlocks == 0 )
+ return error( skin.error());
+
+ bool secondOrder = aMesh.NbFaces( ORDER_QUADRATIC );
+
+ int entity = secondOrder ? SMDSEntity_Quad_Hexa : SMDSEntity_Hexa;
+ vector<int>& nbByType = aResMap[ aMesh.GetSubMesh( aShape )];
+ if ( entity >= nbByType.size() )
+ nbByType.resize( SMDSEntity_Last, 0 );
+
+ for ( int i = 0; i < nbBlocks; ++i )
+ {
+ const _Block& block = skin.getBlock( i );
+
+ int nbX = block.getSide(B_BOTTOM).getHoriSize();
+ int nbY = block.getSide(B_BOTTOM).getVertSize();
+ int nbZ = block.getSide(B_FRONT ).getVertSize();
+
+ int nbHexa = (nbX-1) * (nbY-1) * (nbZ-1);
+ int nbNodes = (nbX-2) * (nbY-2) * (nbZ-2);
+ if ( secondOrder )
+ nbNodes +=
+ (nbX-2) * (nbY-2) * (nbZ-1) +
+ (nbX-2) * (nbY-1) * (nbZ-2) +
+ (nbX-1) * (nbY-2) * (nbZ-2);
+
+
+ nbByType[ entity ] += nbHexa;
+ nbByType[ SMDSEntity_Node ] += nbNodes;
+ }
+
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Abstract method must be defined but does nothing
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::CheckHypothesis(SMESH_Mesh&, const TopoDS_Shape&,
+ Hypothesis_Status& aStatus)
+{
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Abstract method must be defined but just reports an error as this
+ * algo is not intended to work with shapes
+ */
+//================================================================================
+
+bool SMESH_HexaFromSkin_3D::Compute(SMESH_Mesh&, const TopoDS_Shape&)
+{
+ return error("Algorithm can't work with geometrical shapes");
+}
+
+
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : SMESH_HexaFromSkin_3D.hxx
+// Created : Wed Jan 27 12:23:21 2010
+// Author : Edward AGAPOV (eap)
+//
+#ifndef __SMESH_HexaFromSkin_3D_HXX__
+#define __SMESH_HexaFromSkin_3D_HXX__
+
+#include "SMESH_StdMeshers.hxx"
+#include "SMESH_3D_Algo.hxx"
+
+// from HexaBlocks
+#include "hexa_base.hxx"
+#include "HexDocument.hxx"
+#include "HexVertex.hxx"
+// #include "HexEdge.hxx"
+// #include "HexQuad.hxx"
+#include "HexHexa.hxx"
+#include "HEXABLOCKPlugin_mesh.hxx"
+
+/*!
+ * \brief Alorithm generating hexahedral mesh from 2D skin of block
+ */
+
+class STDMESHERS_EXPORT SMESH_HexaFromSkin_3D : public SMESH_3D_Algo
+{
+public:
+// SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen);
+ SMESH_HexaFromSkin_3D(int hypId, int studyId, SMESH_Gen* gen, HEXA_NS::Document* doc);
+ virtual ~SMESH_HexaFromSkin_3D();
+
+ virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper);
+ virtual bool Compute(SMESH_Mesh & aMesh, SMESH_MesherHelper* aHelper,
+ std::map<HEXA_NS::Hexa*, SMESH_HexaBlocks::SMESHVolumes>& volumesOnHexa,
+ std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> vertexNode );
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);
+
+ virtual bool Evaluate(SMESH_Mesh & aMesh,
+ const TopoDS_Shape & aShape,
+ MapShapeNbElems& aResMap);
+
+private:
+ HEXA_NS::Document* _doc;
+
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File : HEXABLOCKPlugin_HEXABLOCK.cxx
+// Created :
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Project : SALOME
+// $Header$
+//=============================================================================
+//
+#include "HEXABLOCKPlugin_HEXABLOCK.hxx"
+#include "HEXABLOCKPlugin_Hypothesis.hxx"
+
+#include "TopExp_Explorer.hxx"
+
+#include <Basics_Utils.hxx>
+
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MesherHelper.hxx"
+
+#include "HEXABLOCKPlugin_mesh.hxx"
+
+#include "HexQuad.hxx"
+#include "HexEdge.hxx"
+#include "HexVertex.hxx"
+#include "HexPropagation.hxx"
+
+#include "utilities.h"
+
+using namespace std;
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK::HEXABLOCKPlugin_HEXABLOCK(int hypId, int studyId, SMESH_Gen* gen)
+ : SMESH_3D_Algo(hypId, studyId, gen)
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::HEXABLOCKPlugin_HEXABLOCK");
+ _name = "HEXABLOCK_3D";
+ _shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
+ _compatibleHypothesis.push_back("HEXABLOCK_Parameters");
+ _requireShape = false; // can work without shape
+ _requireDiscreteBoundary = false;
+ _hyp = NULL;
+ _supportSubmeshes = false;
+ _iShape = 0;
+ _nbShape = 0;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK::~HEXABLOCKPlugin_HEXABLOCK()
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::~HEXABLOCKPlugin_HEXABLOCK");
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::CheckHypothesis ( SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ Hypothesis_Status& aStatus )
+{
+ aStatus = SMESH_Hypothesis::HYP_OK;
+
+ // there is only one compatible Hypothesis so far
+ _hyp = 0;
+ const list <const SMESHDS_Hypothesis * >& hyps = GetUsedHypothesis(aMesh, aShape);
+ if ( !hyps.empty() )
+ _hyp = static_cast<const HEXABLOCKPlugin_Hypothesis*> ( hyps.front() );
+
+ return true;
+}
+
+//=============================================================================
+/*!
+ *Here we are going to use the HEXABLOCK mesher
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape) {
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute with a shape");
+
+ SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
+ if ( (_iShape == 0) && (_nbShape == 0) ) {
+ TopExp_Explorer expShape ( meshDS->ShapeToMesh(), TopAbs_SOLID );
+ for ( ; expShape.More(); expShape.Next() ) {
+ _nbShape++;
+ }
+ }
+
+ // to prevent from displaying error message after computing,
+ for ( int i = 0; i < _nbShape; ++i )
+ if ( SMESH_subMesh* sm = theMesh.GetSubMeshContaining( theShape ))
+ {
+ SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
+ /*complexShapeFirst=*/false);
+ while ( smIt->more() )
+ {
+ sm = smIt->next();
+ if ( !sm->IsMeshComputed() )
+ sm->SetIsAlwaysComputed( true );
+ }
+ }
+
+
+ _iShape++;
+
+ if ( _iShape == _nbShape ) {
+ _nbShape = 0;
+ _iShape = 0;
+
+ switch (_hyp->GetDimension()) {
+ case 0 : return( Compute0D(theMesh) );
+ case 1 : return( Compute1D(theMesh) );
+ case 2 : return( Compute2D(theMesh) );
+ default: return( Compute3D(theMesh) );
+ };
+ }
+}
+
+//=============================================================================
+/*!
+ *Here we are going to use the HEXABLOCK mesher w/o geometry
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute(SMESH_Mesh& theMesh,
+ SMESH_MesherHelper* aHelper)
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute without a shape");
+
+ switch (_hyp->GetDimension()) {
+ case 0 : return( Compute0D(theMesh) );
+ case 1 : return( Compute1D(theMesh) );
+ case 2 : return( Compute2D(theMesh) );
+ default: return( Compute3D(theMesh) );
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+bool HEXABLOCKPlugin_HEXABLOCK::Evaluate(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ MapShapeNbElems& aResMap)
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Evaluate: do nothing");
+
+ return true;
+}
+
+//=============================================================================
+/*!
+ * Generate hexehedral
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute3D(SMESH_Mesh& theMesh) {
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 3D Begin");
+
+ SMESH_HexaBlocks hexaBuilder(theMesh);
+
+ HEXA_NS::Document* doc = _hyp->GetDocument();
+ // doc->reorderFaces (); // 0) Abu 06/03/2012
+
+ hexaBuilder.computeDoc(doc);
+ hexaBuilder.buildGroups(doc);
+
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 3D End");
+ return true;
+}
+
+//=============================================================================
+/*!
+ * Generate quadrangles
+ */
+//=============================================================================
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute2D(SMESH_Mesh& theMesh)
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 2D");
+
+ HEXA_NS::Document* doc = _hyp->GetDocument();
+ // doc->reorderFaces (); // 0) Abu 06/03/2012
+
+ SMESH_HexaBlocks hexaBuilder(theMesh);
+
+ // A) Vertex computation
+ int nVertex = doc->countUsedVertex();
+ HEXA_NS::Vertex* vertex = NULL;
+ for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+ vertex = doc->getUsedVertex(j);
+ hexaBuilder.computeVertex(*vertex);
+ };
+
+ // B) Edges computation
+ int nbPropa = 0;
+ HEXA_NS::Propagation* propa = NULL;
+ HEXA_NS::Law* law = NULL;
+ HEXA_NS::Edges edges;
+
+ nbPropa = doc->countPropagation();
+ for (int j=0; j < nbPropa; ++j ){ //Computing each edge's propagations of the document
+ propa = doc->getPropagation(j);
+ edges = propa->getEdges();
+ law = propa->getLaw();
+ if (law == NULL){
+ law = doc->getLaw(0); // default law
+ };
+ for( HEXA_NS::Edges::const_iterator iter = edges.begin(); iter != edges.end(); ++iter ) {
+ hexaBuilder.computeEdge(**iter, *law);
+ };
+ };
+
+ // C) Quad computation
+ std::map<HEXA_NS::Quad*, bool> quadWays = hexaBuilder.computeQuadWays(doc);
+ int nQuad = doc->countUsedQuad();
+ HEXA_NS::Quad* quad = NULL;
+ for (int j=0; j <nQuad; ++j ){ //Computing each quad of the document
+ quad = doc->getUsedQuad(j);
+ int id = quad->getId();
+ if ( quadWays.count(quad) > 0 )
+ hexaBuilder.computeQuad(*quad, quadWays[quad]);
+ else
+ if(MYDEBUG) MESSAGE("NO QUAD WAY ID = "<<id);
+ };
+
+ // D) build Groups
+ hexaBuilder.buildGroups(doc);
+
+ return true;
+}
+
+// SMESH::SMESH_Mesh_ptr SMESH_Gen_i::HexaBlocksQuad( HEXABLOCK_ORB::Document_ptr docIn, ::CORBA::Long quadID )
+// {
+// try {
+// SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
+// if ( !aNewMesh->_is_nil() ) {
+// SMESH_Mesh_i* aNewImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() );
+// Document_impl* docServant = dynamic_cast<Document_impl*>( GetServant( docIn ).in() );
+// ASSERT( aNewImpl );
+// ASSERT( docServant );
+
+// HEXA_NS::Document* doc = docServant->GetImpl();
+// SMESH_HexaBlocks hexaBuilder(aNewImpl);
+
+// // A) Vertex computation
+// int nVertex = doc->countVertex();
+// HEXA_NS::Vertex* vertex = NULL;
+// for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+// vertex = doc->getUsedVertex(j);
+// hexaBuilder.computeVertex(*vertex);
+// }
+
+// // B) Edges computation
+// int nbPropa = 0;
+// HEXA_NS::Propagation* propa = NULL;
+// HEXA_NS::Law* law = NULL;
+// HEXA_NS::Edges edges;
+
+// nbPropa = doc->countPropagation();
+// for (int j=0; j < nbPropa; ++j ){//Computing each edge's propagations of the document
+// propa = doc->getPropagation(j);
+// edges = propa->getEdges();
+// law = propa->getLaw();
+// // ASSERT( law );
+// if (law == NULL){
+// law = doc->getLaw(0); // default law
+// }
+// for( HEXA_NS::Edges::const_iterator iter = edges.begin();
+// iter != edges.end();
+// ++iter ){
+// hexaBuilder.computeEdge(**iter, *law);
+// }
+// }
+
+// // C) Quad computation
+// std::map<HEXA_NS::Quad*, bool> quadWays = hexaBuilder.computeQuadWays(*doc);
+// int nQuad = doc->countQuad();
+// HEXA_NS::Quad* quad = NULL;
+// for (int j=0; j <nQuad; ++j ){ //Computing each quad of the document
+// quad = doc->getQuad(j);
+// int id = quad->getId();
+// if ( quadID == id and (quadWays.count(quad) > 0) )
+// hexaBuilder.computeQuad( *quad, quadWays[quad] );
+
+// if ( quadWays.count(quad) == 0 )
+// if(MYDEBUG) MESSAGE("NO QUAD WAY ID = "<<id);
+
+// }
+
+// // D) build Groups
+// hexaBuilder.buildGroups(doc);
+
+// }
+// return aNewMesh._retn();
+// } catch (SALOME_Exception& S_ex) {
+// THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
+// }
+// }
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute1D(SMESH_Mesh& theMesh)
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 1D");
+
+ HEXA_NS::Document* doc = _hyp->GetDocument();
+ // doc->reorderFaces (); // 0) Abu 06/03/2012
+
+ SMESH_HexaBlocks hexaBuilder(theMesh);
+
+ // A) Vertex computation
+ int nVertex = doc->countUsedVertex();
+ HEXA_NS::Vertex* vertex = NULL;
+ for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+ vertex = doc->getUsedVertex(j);
+ hexaBuilder.computeVertex(*vertex);
+ };
+
+ // B) Edges computation
+ int nbPropa = 0;
+ HEXA_NS::Propagation* propa = NULL;
+ HEXA_NS::Law* law = NULL;
+ HEXA_NS::Edges edges;
+
+ nbPropa = doc->countPropagation();
+ for (int j=0; j < nbPropa; ++j ){//Computing each edge's propagations of the document
+ propa = doc->getPropagation(j);
+ edges = propa->getEdges();
+ law = propa->getLaw();
+ // ASSERT( law );
+ if (law == NULL){
+ law = doc->getLaw(0); // default law
+ };
+ for( HEXA_NS::Edges::const_iterator iter = edges.begin(); iter != edges.end(); ++iter ) {
+ hexaBuilder.computeEdge(**iter, *law);
+ };
+ };
+
+ // C) build Groups
+ hexaBuilder.buildGroups(doc);
+
+ return true;
+}
+
+bool HEXABLOCKPlugin_HEXABLOCK::Compute0D(SMESH_Mesh& theMesh)
+{
+ if(MYDEBUG) MESSAGE("HEXABLOCKPlugin_HEXABLOCK::Compute 0D");
+
+ HEXA_NS::Document* doc = _hyp->GetDocument();
+ // doc->reorderFaces (); // 0) Abu 06/03/2012
+
+ SMESH_HexaBlocks hexaBuilder(theMesh);
+
+ // A) Vertex computation
+ int nVertex = doc->countUsedVertex();
+ HEXA_NS::Vertex* vertex = NULL;
+ for ( int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+ vertex = doc->getUsedVertex(j);
+ hexaBuilder.computeVertex(*vertex);
+ };
+
+ // B) build Groups
+ hexaBuilder.buildGroups(doc);
+
+ return true;
+}
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File : HEXABLOCKPlugin_HEXABLOCK.hxx
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Project : SALOME
+// $Header$
+//=============================================================================
+//
+#ifndef _HEXABLOCKPlugin_HEXABLOCK_HXX_
+#define _HEXABLOCKPlugin_HEXABLOCK_HXX_
+
+#include "SMESH_3D_Algo.hxx"
+#include "SMESH_Mesh.hxx"
+
+class SMESH_Mesh;
+class HEXABLOCKPlugin_Hypothesis;
+
+class HEXABLOCKPlugin_HEXABLOCK: public SMESH_3D_Algo
+{
+public:
+ HEXABLOCKPlugin_HEXABLOCK(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~HEXABLOCKPlugin_HEXABLOCK();
+
+ virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape,
+ Hypothesis_Status& aStatus);
+
+ virtual bool Compute(SMESH_Mesh& aMesh,
+ const TopoDS_Shape& aShape);
+
+ virtual bool Evaluate(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape,
+ MapShapeNbElems& aResMap);
+
+ virtual bool Compute(SMESH_Mesh& theMesh,
+ SMESH_MesherHelper* aHelper);
+
+ bool Compute3D(SMESH_Mesh& aMesh);
+ bool Compute2D(SMESH_Mesh& aMesh);
+ bool Compute1D(SMESH_Mesh& aMesh);
+ bool Compute0D(SMESH_Mesh& aMesh);
+
+private:
+ const HEXABLOCKPlugin_Hypothesis* _hyp;
+ int _iShape;
+ int _nbShape;
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
+// File : HEXABLOCKPlugin_HEXABLOCK_i.cxx
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Module : HEXABLOCKPlugin
+// $Header$
+//
+#include "HEXABLOCKPlugin_HEXABLOCK_i.hxx"
+#include "SMESH_Gen.hxx"
+#include "HEXABLOCKPlugin_HEXABLOCK.hxx"
+
+#include "utilities.h"
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+using namespace std;
+
+//=============================================================================
+/*!
+ * HEXABLOCKPlugin_HEXABLOCK_i::HEXABLOCKPlugin_HEXABLOCK_i
+ *
+ * Constructor
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK_i::HEXABLOCKPlugin_HEXABLOCK_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl )
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ SMESH_Algo_i( thePOA ),
+ SMESH_3D_Algo_i( thePOA )
+{
+ if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_HEXABLOCK_i::HEXABLOCKPlugin_HEXABLOCK_i" );
+ myBaseImpl = new ::HEXABLOCKPlugin_HEXABLOCK (theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl );
+}
+
+//=============================================================================
+/*!
+ * HEXABLOCKPlugin_HEXABLOCK_i::~HEXABLOCKPlugin_HEXABLOCK_i
+ *
+ * Destructor
+ */
+//=============================================================================
+
+HEXABLOCKPlugin_HEXABLOCK_i::~HEXABLOCKPlugin_HEXABLOCK_i()
+{
+ if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_HEXABLOCK_i::~HEXABLOCKPlugin_HEXABLOCK_i" );
+}
+
+//=============================================================================
+/*!
+ * HEXABLOCKPlugin_HEXABLOCK_i::GetImpl
+ *
+ * Get implementation
+ */
+//=============================================================================
+
+::HEXABLOCKPlugin_HEXABLOCK* HEXABLOCKPlugin_HEXABLOCK_i::GetImpl()
+{
+ if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_HEXABLOCK_i::GetImpl" );
+ return ( ::HEXABLOCKPlugin_HEXABLOCK* )myBaseImpl;
+}
+
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : HEXABLOCKPlugin_HEXABLOCK_i.hxx
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Module : HEXABLOCKPlugin
+// $Header$
+//
+#ifndef _HEXABLOCKPlugin_HEXABLOCK_I_HXX_
+#define _HEXABLOCKPlugin_HEXABLOCK_I_HXX_
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(HEXABLOCKPlugin_Algorithm)
+#include CORBA_SERVER_HEADER(SALOME_Exception)
+
+#include "SMESH_3D_Algo_i.hxx"
+#include "HEXABLOCKPlugin_HEXABLOCK.hxx"
+
+// ======================================================
+// HEXABLOCK 3d algorithm
+// ======================================================
+class HEXABLOCKPlugin_HEXABLOCK_i:
+ public virtual POA_HEXABLOCKPlugin::HEXABLOCKPlugin_HEXABLOCK,
+ public virtual SMESH_3D_Algo_i
+{
+public:
+ // Constructor
+ HEXABLOCKPlugin_HEXABLOCK_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl );
+ // Destructor
+ virtual ~HEXABLOCKPlugin_HEXABLOCK_i();
+
+ // Get implementation
+ ::HEXABLOCKPlugin_HEXABLOCK* GetImpl();
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+//=============================================================================
+// File : HEXABLOCKPlugin_Hypothesis.cxx
+// Created : Wed Apr 2 12:36:29 2008
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+//=============================================================================
+//
+#include "HEXABLOCKPlugin_Hypothesis.hxx"
+
+//=======================================================================
+//function : HEXABLOCKPlugin_Hypothesis
+//=======================================================================
+
+HEXABLOCKPlugin_Hypothesis::HEXABLOCKPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen)
+ : SMESH_Hypothesis(hypId, studyId, gen),
+ _document(NULL),
+ _dimension(3)
+{
+ _name = "HEXABLOCK_Parameters";
+ _param_algo_dim = 3;
+}
+
+//=======================================================================
+//function : GetDocument
+//=======================================================================
+
+HEXA_NS::Document* HEXABLOCKPlugin_Hypothesis::GetDocument() const
+{
+ return(_document);
+}
+
+//=======================================================================
+//function : SetDocument
+//=======================================================================
+
+void HEXABLOCKPlugin_Hypothesis::SetDocument(HEXA_NS::Document* doc)
+{
+ _document = doc;
+}
+
+//=======================================================================
+//function : GetDimension
+//=======================================================================
+
+int HEXABLOCKPlugin_Hypothesis::GetDimension() const
+{
+ return(_dimension);
+}
+
+//=======================================================================
+//function : SetDimension
+//=======================================================================
+
+void HEXABLOCKPlugin_Hypothesis::SetDimension(int dim)
+{
+ _dimension = dim;
+}
+
+//=======================================================================
+//function : SaveTo
+//=======================================================================
+
+std::ostream & HEXABLOCKPlugin_Hypothesis::SaveTo(std::ostream & save)
+{
+//save << _document->getXML() << " ";
+ save <<_dimension << " ";
+
+ return save;
+}
+
+//=======================================================================
+//function : LoadFrom
+//=======================================================================
+
+std::istream & HEXABLOCKPlugin_Hypothesis::LoadFrom(std::istream & load)
+{
+ bool isOK = true;
+ int i;
+
+// char* str;
+// isOK = (load >> str);
+// if (isOK)
+// _document = xml_2_doc(str);
+// else
+// load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> i);
+ if (isOK)
+ _dimension = i;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ return load;
+}
+
+//=======================================================================
+//function : SetParametersByMesh
+//=======================================================================
+
+bool HEXABLOCKPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
+{
+ return false;
+}
+
+
+//================================================================================
+/*!
+ * \brief Return false
+ */
+//================================================================================
+
+bool HEXABLOCKPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& /*dflts*/,
+ const SMESH_Mesh* /*theMesh*/)
+{
+ return false;
+}
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// HEXABLOCKPlugin : C++ implementation
+// File : HEXABLOCKPlugin_Hypothesis.hxx
+// Created : Wed Apr 2 12:21:17 2008
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+//
+#ifndef HEXABLOCKPlugin_Hypothesis_HeaderFile
+#define HEXABLOCKPlugin_Hypothesis_HeaderFile
+
+#include "HEXABLOCKPlugin_Defs.hxx"
+
+#include <SMESH_Hypothesis.hxx>
+
+#include "HexDocument.hxx"
+
+#include <utilities.h>
+
+#include <stdexcept>
+#include <cstdio>
+
+class HEXABLOCKPLUGIN_EXPORT HEXABLOCKPlugin_Hypothesis: public SMESH_Hypothesis
+{
+public:
+
+ HEXABLOCKPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen);
+
+ /*!
+ * Define the document to be meshed, mandatory
+ */
+ void SetDocument(HEXA_NS::Document* doc);
+ HEXA_NS::Document* GetDocument() const;
+
+ /*!
+ * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+ */
+ void SetDimension(int dim);
+ int GetDimension() const;
+
+ // Persistence
+ virtual std::ostream & SaveTo(std::ostream & save);
+ virtual std::istream & LoadFrom(std::istream & load);
+ friend HEXABLOCKPLUGIN_EXPORT std::ostream & operator <<(std::ostream & save, HEXABLOCKPlugin_Hypothesis & hyp);
+ friend HEXABLOCKPLUGIN_EXPORT std::istream & operator >>(std::istream & load, HEXABLOCKPlugin_Hypothesis & hyp);
+
+ /*!
+ * \brief Does nothing
+ */
+ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+ /*!
+ * \brief Does nothing
+ */
+ virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
+
+private:
+ HEXA_NS::Document* _document;
+ int _dimension;
+};
+
+
+#endif
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : HEXABLOCKPlugin_Hypothesis_i.cxx
+// Created : Wed Apr 2 13:53:01 2008
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+//
+#include <SMESH_Gen.hxx>
+#include <SMESH_PythonDump.hxx>
+#include <SMESH_Mesh_i.hxx>
+
+#include "HEXABLOCK.hxx"
+#include "HEXABLOCKPlugin_Hypothesis_i.hxx"
+#include "HexDocument_impl.hxx"
+
+#include <Utils_CorbaException.hxx>
+#include <utilities.h>
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+//=======================================================================
+//function : HEXABLOCKPlugin_Hypothesis_i
+//=======================================================================
+
+HEXABLOCKPlugin_Hypothesis_i::HEXABLOCKPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl)
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_Hypothesis_i::HEXABLOCKPlugin_Hypothesis_i" );
+ myBaseImpl = new ::HEXABLOCKPlugin_Hypothesis (theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl);
+ _poa = PortableServer::POA::_duplicate(thePOA);
+}
+
+//=======================================================================
+//function : ~HEXABLOCKPlugin_Hypothesis_i
+//=======================================================================
+
+HEXABLOCKPlugin_Hypothesis_i::~HEXABLOCKPlugin_Hypothesis_i()
+{
+ if(MYDEBUG) MESSAGE( "HEXABLOCKPlugin_Hypothesis_i::~HEXABLOCKPlugin_Hypothesis_i" );
+}
+
+//=============================================================================
+/*!
+ * Get implementation
+ */
+//=============================================================================
+
+::HEXABLOCKPlugin_Hypothesis* HEXABLOCKPlugin_Hypothesis_i::GetImpl()
+{
+ return (::HEXABLOCKPlugin_Hypothesis*)myBaseImpl;
+}
+
+//================================================================================
+/*!
+ * \brief Verify whether hypothesis supports given entity type
+ */
+//================================================================================
+
+CORBA::Boolean HEXABLOCKPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
+{
+ return type == SMESH::DIM_3D;
+}
+
+//================================================================================
+/*!
+ * Define the document to be meshed, mandatory
+ */
+//================================================================================
+
+HEXABLOCK_ORB::Document_ptr HEXABLOCKPlugin_Hypothesis_i::GetDocument() {
+ ASSERT(myBaseImpl);
+ HEXA_NS::Document* d = this->GetImpl()->GetDocument();
+ Document_impl* servantCorba = new Document_impl(_poa, d);
+ HEXABLOCK_ORB::Document_ptr result = servantCorba->_this();
+ return result;
+}
+
+void HEXABLOCKPlugin_Hypothesis_i::SetDocument(HEXABLOCK_ORB::Document_ptr doc) {
+ Document_impl* docServant = ::DownCast<Document_impl*>(doc);
+ if ( docServant ) {
+ HEXA_NS::Document* d = docServant->GetImpl();
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetDocument(d);
+ }
+}
+
+//================================================================================
+/*!
+ * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+ */
+//================================================================================
+
+CORBA::Long HEXABLOCKPlugin_Hypothesis_i::GetDimension() {
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetDimension();
+}
+
+void HEXABLOCKPlugin_Hypothesis_i::SetDimension(CORBA::Long dim) {
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetDimension(dim);
+}
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// HEXABLOCKPlugin : C++ implementation
+// File : HEXABLOCKPlugin_Hypothesis_i.hxx
+// Date : 2010/11/08
+// Project : SALOME
+//
+#ifndef _HEXABLOCKPlugin_Hypothesis_i_HXX_
+#define _HEXABLOCKPlugin_Hypothesis_i_HXX_
+
+#include "HEXABLOCKPlugin_Defs.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(HEXABLOCKPlugin_Algorithm)
+#include CORBA_CLIENT_HEADER(Document)
+
+#include "SMESH_Hypothesis_i.hxx"
+#include "HEXABLOCKPlugin_Hypothesis.hxx"
+
+class SMESH_Gen;
+
+// HEXABLOCKPlugin parameters hypothesis
+
+class HEXABLOCKPLUGIN_EXPORT HEXABLOCKPlugin_Hypothesis_i:
+ public virtual POA_HEXABLOCKPlugin::HEXABLOCKPlugin_Hypothesis,
+ public virtual SMESH_Hypothesis_i
+{
+ public:
+ // Constructor
+ HEXABLOCKPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl);
+ // Destructor
+ virtual ~HEXABLOCKPlugin_Hypothesis_i();
+
+ /*!
+ * Define the document to be meshed, mandatory
+ */
+ HEXABLOCK_ORB::Document_ptr GetDocument();
+ void SetDocument(HEXABLOCK_ORB::Document_ptr doc);
+
+ /*!
+ * To define the hight dimension to generated: 3 = hexas, 2 = quads, 1 = segments, 0 = nodes
+ */
+ CORBA::Long GetDimension();
+ void SetDimension(CORBA::Long dim);
+
+ // Get implementation
+ ::HEXABLOCKPlugin_Hypothesis* GetImpl();
+
+ // Verify whether hypothesis supports given entity type
+ CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+
+ private:
+ PortableServer::POA_var _poa;// POA reference
+
+};
+
+#endif
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// SMESH HEXABLOCKPlugin : implementaion of SMESH idl descriptions
+// File : HEXABLOCKPlugin.cxx
+// Author : Lioka RAZAFINDRAZAKA (CEA)
+// Module : SMESH
+// $Header$
+//
+#include "SMESH_Hypothesis_i.hxx"
+
+#include "utilities.h"
+
+#include "HEXABLOCKPlugin_HEXABLOCK_i.hxx"
+#include "HEXABLOCKPlugin_Hypothesis_i.hxx"
+
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+using namespace std;
+
+template <class T> class HEXABLOCKPlugin_Creator_i:public HypothesisCreator_i<T>
+{
+ // as we have 'module HEXABLOCKPlugin' in HEXABLOCKPlugin_Algorithm.idl
+ virtual std::string GetModuleName() { return "HEXABLOCKPlugin"; }
+};
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+
+extern "C"
+{
+ HEXABLOCKPLUGIN_EXPORT
+ GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
+ {
+ if(MYDEBUG) MESSAGE("GetHypothesisCreator " << aHypName);
+
+ GenericHypothesisCreator_i* aCreator = 0;
+
+ // Hypotheses
+
+ // Algorithm
+ if (strcmp(aHypName, "HEXABLOCK_3D") == 0)
+ aCreator = new HEXABLOCKPlugin_Creator_i<HEXABLOCKPlugin_HEXABLOCK_i>;
+ // Hypothesis
+ else if (strcmp(aHypName, "HEXABLOCK_Parameters") == 0)
+ aCreator = new HEXABLOCKPlugin_Creator_i<HEXABLOCKPlugin_Hypothesis_i>;
+ else ;
+
+ return aCreator;
+ }
+}
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File : SMESH_HexaBlocks.cxx
+// Author :
+// Module : SMESH
+//
+
+#include <sstream>
+#include <algorithm>
+
+// CasCade includes
+#include <AIS_Shape.hxx>
+
+#include <Precision.hxx>
+#include <BRep_Tool.hxx>
+#include <BRepTools.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+
+#include <GeomConvert_CompCurveToBSplineCurve.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <TopoDS_Wire.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Compound.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Lin.hxx>
+#include <IntCurvesFace_ShapeIntersector.hxx>
+
+// SMESH includes
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_MeshVolume.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMESHDS_Group.hxx"
+
+// HEXABLOCK includes
+#include "HexDocument.hxx"
+#include "HexVertex.hxx"
+#include "HexEdge.hxx"
+#include "HexQuad.hxx"
+#include "HexHexa.hxx"
+#include "HexPropagation.hxx"
+#include "HexShape.hxx"
+#include "HexGroup.hxx"
+
+// HEXABLOCKPLUGIN includes
+#include "HEXABLOCKPlugin_mesh.hxx"
+#include "HEXABLOCKPlugin_FromSkin_3D.hxx"
+
+// other includes
+#include "Basics_Utils.hxx"
+#include "utilities.h"
+
+#ifdef WNT
+#include <process.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <stdexcept>
+
+#ifndef EXCEPTION
+#define EXCEPTION(TYPE, MSG) {\
+ std::ostringstream aStream;\
+ aStream<<__FILE__<<"["<<__LINE__<<"]::"<<MSG;\
+ throw TYPE(aStream.str());\
+}
+#endif
+
+#ifdef _DEBUG_
+static int MYDEBUG = 1;
+#else
+static int MYDEBUG = 0;
+#endif
+
+
+static double HEXA_EPSILON = 1E-3; //1E-3;
+static double HEXA_QUAD_WAY = PI/4.; //3.*PI/8.;
+// static double HEXA_QUAD_WAY2 = 499999999.*PI/1000000000.;
+
+
+TopoDS_Shape string2shape( const string& brep )
+{
+ TopoDS_Shape shape;
+ istringstream streamBrep(brep);
+ BRep_Builder aBuilder;
+ BRepTools::Read(shape, streamBrep, aBuilder);
+ return shape;
+}
+
+
+bool shape2coord(const TopoDS_Shape& aShape, double& x, double& y, double& z)
+{
+ if ( aShape.ShapeType() == TopAbs_VERTEX ){
+ TopoDS_Vertex aPoint;
+ aPoint = TopoDS::Vertex( aShape );
+ gp_Pnt aPnt = BRep_Tool::Pnt( aPoint );
+ x = aPnt.X();
+ y = aPnt.Y();
+ z = aPnt.Z();
+ return(1);
+ } else {
+ return(0);
+ };
+}
+
+
+
+// SMESH_HexaBlocks::SMESH_HexaBlocks( SMESH_Mesh* theMesh ):
+SMESH_HexaBlocks::SMESH_HexaBlocks(SMESH_Mesh& theMesh):
+ _total(0),
+ _found(0),
+ _notFound(0),
+ _computeVertexOK(false),
+ _computeEdgeOK(false),
+ _computeQuadOK(false),
+ _theMesh(&theMesh), //groups creation
+ _theMeshDS(theMesh.GetMeshDS()) //meshing
+{
+}
+
+
+SMESH_HexaBlocks::~SMESH_HexaBlocks()
+{
+}
+
+
+// --------------------------------------------------------------
+// PUBLIC METHODS
+// --------------------------------------------------------------
+
+// --------------------------------------------------------------
+// Vertex computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeVertex(HEXA_NS::Vertex& vx)
+{
+ bool ok = false;
+ ok = computeVertexByAssoc( vx );
+ if ( ok == false ){
+ ok = computeVertexByModel( vx );
+ }
+ if (ok == true){
+ _computeVertexOK = true;
+ }
+ return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeVertexByAssoc(HEXA_NS::Vertex& vx)
+{
+ if(MYDEBUG) MESSAGE("computeVertexByAssoc() : : begin <<<<<<");
+ bool ok = true;
+
+ SMDS_MeshNode* newNode = NULL; // new node on mesh
+ double x, y, z; //new node coordinates
+
+ HEXA_NS::Shape* assoc = vx.getAssociation();
+ if ( assoc == NULL ){
+ if (MYDEBUG){
+ MESSAGE("computeVertexByAssoc() : ASSOC not found " << vx.getName ());
+ // vx.printName();
+ }
+ return false;
+ }
+
+ string strBrep = assoc->getBrep();
+ TopoDS_Shape shape = string2shape( strBrep );
+ ok = shape2coord( shape, x, y, z );
+// ASSERT(ok);
+ if (!ok) throw (SALOME_Exception(LOCALIZED("vertex association : shape2coord() error ")));
+ newNode = _theMeshDS->AddNode(x, y, z);
+ if (_node.count(&vx) >= 1 and MYDEBUG) MESSAGE("_node : ALREADY");
+ _node[&vx] = newNode;//needed in computeEdge()
+ _vertex[newNode] = &vx;
+
+ if (MYDEBUG){
+ MESSAGE("computeVertexByAssoc() : ASSOC found " << vx.getName());
+ /// vx.printName();
+ MESSAGE("( "<< x <<","<< y <<","<< z <<" )");
+ }
+
+ if(MYDEBUG) MESSAGE("computeVertexByAssoc() : end >>>>>>>>");
+ return ok;
+}
+
+bool SMESH_HexaBlocks::computeVertexByModel(HEXA_NS::Vertex& vx)
+{
+ if(MYDEBUG) MESSAGE("computeVertexByModel() : : begin <<<<<<");
+ bool ok = true;
+
+ SMDS_MeshNode* newNode = NULL; // new node on mesh
+ double x, y, z; //new node coordinates
+
+// vx.printName();
+// std::cout << std::endl;
+ x = vx.getX();
+ y = vx.getY();
+ z = vx.getZ();
+
+ newNode = _theMeshDS->AddNode(x, y, z);
+
+ if (_node.count(&vx) >= 1 and MYDEBUG) MESSAGE("_node : ALREADY");
+ _node[&vx] = newNode;//needed in computeEdge()
+ _vertex[newNode] = &vx;
+ if (MYDEBUG){
+ MESSAGE("computeVertexByModel() :" << vx.getName());
+ /// vx.printName();
+ MESSAGE("( "<< x <<","<< y <<","<< z <<" )");
+ }
+
+ if(MYDEBUG) MESSAGE("computeVertexByModel() : end >>>>>>>>");
+ return ok;
+}
+
+// --------------------------------------------------------------
+// Edge computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeEdge(HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+ bool ok = false;
+
+ ok = computeEdgeByAssoc( edge, law);
+ if ( ok == false ){
+ ok = computeEdgeByShortestWire( edge, law);
+ }
+ if ( ok == false ){
+ ok = computeEdgeByPlanWire( edge, law);
+ }
+ if ( ok == false ){
+ ok = computeEdgeByIsoWire( edge, law);
+ }
+ if ( ok == false ){
+ ok = computeEdgeBySegment( edge, law);
+ }
+ if (ok == true){
+ _computeEdgeOK = true;
+ }
+ return ok;
+}
+
+
+
+bool SMESH_HexaBlocks::computeEdgeByAssoc( HEXA_NS::Edge& edge, HEXA_NS::Law& law )
+{
+ if(MYDEBUG) MESSAGE("computeEdgeByAssoc(edgeID = "<<edge.getId()<<"): begin <<<<<<");
+ ASSERT( _computeVertexOK );
+ bool ok = true;
+
+ const std::vector <HEXA_NS::Shape*> associations = edge.getAssociations();
+ if ( associations.size() == 0 ){
+ return false;
+ }
+ //vertex from edge
+ HEXA_NS::Vertex* vx0 = NULL;
+ HEXA_NS::Vertex* vx1 = NULL;
+
+ // way of discretization
+ if (edge.getWay() == true){
+ vx0 = edge.getVertex(0);
+ vx1 = edge.getVertex(1);
+ } else {
+ vx0 = edge.getVertex(1);
+ vx1 = edge.getVertex(0);
+ }
+ // nodes on mesh
+ SMDS_MeshNode* FIRST_NODE = _node[vx0];
+ SMDS_MeshNode* LAST_NODE = _node[vx1];
+
+
+ // A) Build myCurve
+ std::list< BRepAdaptor_Curve* > myCurve;
+ double myCurve_length;
+ std::map< BRepAdaptor_Curve*, double> myCurve_lengths;
+ std::map< BRepAdaptor_Curve*, bool> myCurve_ways;
+ std::map< BRepAdaptor_Curve*, double> myCurve_starts;
+ gp_Pnt myCurve_start( FIRST_NODE->X(), FIRST_NODE->Y(), FIRST_NODE->Z() );
+ gp_Pnt myCurve_end( LAST_NODE->X(), LAST_NODE->Y(), LAST_NODE->Z() );
+
+
+ _buildMyCurve(
+ associations,
+ myCurve_start,
+ myCurve_end,
+ myCurve,
+ myCurve_length,
+ myCurve_lengths,
+ myCurve_ways,
+ myCurve_starts,
+ edge
+ );
+
+
+ // B) Build nodes and edges on mesh from myCurve
+ SMDS_MeshNode* node_a = NULL;
+ SMDS_MeshNode* node_b = NULL;
+ SMDS_MeshEdge* edge_ab = NULL;
+ SMESHNodes nodesOnEdge;
+ SMESHEdges edgesOnEdge; //backup for group creation
+// Xx nodesXxOnEdge;
+
+ node_a = FIRST_NODE;
+ nodesOnEdge.push_back(FIRST_NODE);
+// nodesXxOnEdge.push_back(0.);
+ // _nodeXx[FIRST_NODE] = 0.;
+
+ gp_Pnt ptOnMyCurve;
+ double u, myCurve_u;
+ double myCurve_start_u = 0.;
+ int nbNodes = law.getNodes(); //law of discretization
+ if (MYDEBUG) MESSAGE("nbNodes -> "<<nbNodes);
+ for (int i = 0; i < nbNodes; ++i){
+ u = _Xx(i, law, nbNodes); //u between [0,1]
+ myCurve_u = u*myCurve_length;
+ if (MYDEBUG) {
+ MESSAGE("u -> "<<u);
+ MESSAGE("myCurve_u -> "<<myCurve_u);
+ MESSAGE("myCurve_length -> "<<myCurve_length);
+ }
+ ptOnMyCurve = _getPtOnMyCurve( myCurve_u,
+ myCurve_ways,
+ myCurve_lengths,
+ myCurve_starts,
+ myCurve,
+ myCurve_start_u
+ );
+
+ node_b = _theMeshDS->AddNode( ptOnMyCurve.X(), ptOnMyCurve.Y(), ptOnMyCurve.Z() );
+ edge_ab = _theMeshDS->AddEdge( node_a, node_b );
+ nodesOnEdge.push_back( node_b );
+ edgesOnEdge.push_back( edge_ab );
+// nodesXxOnEdge.push_back( u );
+ if (_nodeXx.count(node_b) >= 1 ) ASSERT(false);
+ _nodeXx[node_b] = u;
+ node_a = node_b;
+ }
+ edge_ab = _theMeshDS->AddEdge( node_a, LAST_NODE );
+ nodesOnEdge.push_back( LAST_NODE );
+ edgesOnEdge.push_back( edge_ab );
+// nodesXxOnEdge.push_back( 1. );
+ // _nodeXx[LAST_NODE] = 1.;
+ _nodesOnEdge[&edge] = nodesOnEdge;
+ _edgesOnEdge[&edge] = edgesOnEdge;
+
+
+
+// _edgeXx[&edge] = nodesXxOnEdge;
+
+ if(MYDEBUG) MESSAGE("computeEdgeByAssoc() : end >>>>>>>>");
+ return ok;
+}
+
+
+
+
+bool SMESH_HexaBlocks::computeEdgeByShortestWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+ if(MYDEBUG) MESSAGE("computeEdgeByShortestWire() not implemented");
+ return false;
+}
+
+bool SMESH_HexaBlocks::computeEdgeByPlanWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+ if(MYDEBUG) MESSAGE("computeEdgeByPlanWire() not implemented");
+ return false;
+}
+
+bool SMESH_HexaBlocks::computeEdgeByIsoWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+ if(MYDEBUG) MESSAGE("computeEdgeByIsoWire() not implemented");
+ return false;
+}
+
+
+bool SMESH_HexaBlocks::computeEdgeBySegment(HEXA_NS::Edge& edge, HEXA_NS::Law& law)
+{
+ if(MYDEBUG) MESSAGE("computeEdgeBySegment() : : begin <<<<<<");
+ ASSERT( _computeVertexOK );
+ bool ok = true;
+
+ //vertex from edge
+ HEXA_NS::Vertex* vx0 = NULL;
+ HEXA_NS::Vertex* vx1 = NULL;
+
+ // way of discretization
+ if (edge.getWay() == true){
+ vx0 = edge.getVertex(0);
+ vx1 = edge.getVertex(1);
+ } else {
+ vx0 = edge.getVertex(1);
+ vx1 = edge.getVertex(0);
+ }
+
+ // nodes on mesh
+ SMDS_MeshNode* FIRST_NODE = _node[vx0];
+ SMDS_MeshNode* LAST_NODE = _node[vx1];
+ SMDS_MeshNode* node_a = NULL; //new node (to be added)
+ SMDS_MeshNode* node_b = NULL; //new node (to be added)
+
+ // node and edge creation
+ SMESHNodes nodesOnEdge;
+ SMESHEdges edgesOnEdge;
+
+ double u; //
+ double newNodeX, newNodeY, newNodeZ;
+ SMDS_MeshEdge* newEdge = NULL;
+
+ node_a = FIRST_NODE;
+ nodesOnEdge.push_back(FIRST_NODE);
+
+ //law of discretization
+ int nbNodes = law.getNodes();
+ if (MYDEBUG) MESSAGE("nbNodes -> "<<nbNodes);
+ for (int i = 0; i < nbNodes; ++i){
+ u = _Xx(i, law, nbNodes);
+ newNodeX = FIRST_NODE->X() + u * ( LAST_NODE->X() - FIRST_NODE->X() );
+ newNodeY = FIRST_NODE->Y() + u * ( LAST_NODE->Y() - FIRST_NODE->Y() );
+ newNodeZ = FIRST_NODE->Z() + u * ( LAST_NODE->Z() - FIRST_NODE->Z() );
+ node_b = _theMeshDS->AddNode(newNodeX, newNodeY, newNodeZ);
+ newEdge = _theMeshDS->AddEdge(node_a, node_b);
+ edgesOnEdge.push_back(newEdge);
+ nodesOnEdge.push_back(node_b);
+ if (_nodeXx.count(node_b) >= 1 ) ASSERT(false);
+ _nodeXx[ node_b ] = u;
+ if(MYDEBUG) MESSAGE("_nodeXx <-"<<u);
+ node_a = node_b;
+ }
+ newEdge = _theMeshDS->AddEdge(node_a, LAST_NODE);
+ nodesOnEdge.push_back(LAST_NODE);
+ edgesOnEdge.push_back(newEdge);
+
+ _nodesOnEdge[&edge] = nodesOnEdge;
+ _edgesOnEdge[&edge] = edgesOnEdge;
+
+ if(MYDEBUG) MESSAGE("computeEdgeBySegment() : end >>>>>>>>");
+ return ok;
+}
+
+
+// --------------------------------------------------------------
+// Quad computing
+// --------------------------------------------------------------
+std::map<HEXA_NS::Quad*, bool> SMESH_HexaBlocks::computeQuadWays( HEXA_NS::Document* doc )
+{
+ std::map<HEXA_NS::Quad*, bool> quadWays;
+ std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > edgeWays;
+ std::list<HEXA_NS::Quad*> skinQuad;
+ std::list<HEXA_NS::Quad*> workingQuad;
+ HEXA_NS::Quad* first_q = NULL;
+ HEXA_NS::Quad* q = NULL;
+ HEXA_NS::Edge* e = NULL;
+ HEXA_NS::Vertex *e_0, *e_1 = NULL;
+
+ // FIRST STEP: eliminate free quad + internal quad
+ int nTotalQuad = doc->countUsedQuad();
+ for (int i=0; i < nTotalQuad; ++i ){
+ q = doc->getUsedQuad(i);
+ switch ( q->getNbrParents() ){ // parent == hexaedron
+ case 0: case 2: quadWays[q] = true; break;
+ case 1: skinQuad.push_back(q); break;
+ default: if ( q->getNbrParents() > 2 ) ASSERT(false);
+ }
+ }
+
+ // SECOND STEP: setting edges ways
+ while ( skinQuad.size()>0 ){
+ if(MYDEBUG) MESSAGE("SEARCHING INITIAL QUAD ..." );
+ for ( std::list<HEXA_NS::Quad*>::iterator it = skinQuad.begin(); it != skinQuad.end(); it++ ){
+ _searchInitialQuadWay( *it, e_0, e_1 );
+ if ( e_0 != NULL and e_1 != NULL ){
+ q = first_q = *it;
+ break;
+ }
+ }
+ if ( e_0 == NULL and e_1 == NULL ) ASSERT(false);// should never happened,
+ if(MYDEBUG) MESSAGE("INITIAL QUAD FOUND!" );
+ for ( int j=0 ; j < 4 ; ++j ){
+ e = q->getEdge(j);
+ if ( (e_0 == e->getVertex(0)) and (e_1 == e->getVertex(1)) or
+ (e_0 == e->getVertex(1)) and (e_1 == e->getVertex(0)) ){
+ break;
+ }
+ }
+ if(MYDEBUG) MESSAGE("INITIAL EDGE WAY FOUND!" );
+
+ edgeWays[e] = std::make_pair( e_0, e_1 );
+ workingQuad.push_back(q);
+
+ while ( workingQuad.size() > 0 ){
+ if(MYDEBUG) MESSAGE("COMPUTE QUAD WAY ... ID ="<< q->getId());
+ HEXA_NS::Vertex *lastVertex=NULL, *firstVertex = NULL;
+ int i = 0;
+ std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > localEdgeWays;
+ while ( localEdgeWays.size() != 4 ){
+ HEXA_NS::Edge* e = q->getEdge(i%4);
+ if ( lastVertex == NULL ){
+ if ( edgeWays.count(e) == 1 ){
+ if ( q == first_q ){
+ localEdgeWays[e] = std::make_pair( edgeWays[e].first, edgeWays[e].second );
+ } else {
+ localEdgeWays[e] = std::make_pair( edgeWays[e].second, edgeWays[e].first);
+ }
+ firstVertex = localEdgeWays[e].first;
+ lastVertex = localEdgeWays[e].second;
+ }
+ } else {
+ HEXA_NS::Vertex* e_0 = e->getVertex(0);
+ HEXA_NS::Vertex* e_1 = e->getVertex(1);
+
+ if ( lastVertex == e_0 ){
+ firstVertex = e_0; lastVertex = e_1;
+ } else if ( lastVertex == e_1 ){
+ firstVertex = e_1; lastVertex = e_0;
+ } else if ( firstVertex == e_0 ) {
+ firstVertex = e_1; lastVertex = e_0;
+ } else if ( firstVertex == e_1 ) {
+ firstVertex = e_0; lastVertex = e_1;
+ } else {
+ ASSERT(false);
+ }
+ localEdgeWays[e] = std::make_pair( firstVertex, lastVertex );
+ if ( edgeWays.count(e) == 0 ){ // keep current value if present otherwise add it
+ edgeWays[e] = localEdgeWays[e];
+ }
+ }
+ ++i;
+ }
+
+
+ //add new working quad
+ for ( int i=0 ; i < 4; ++i ){
+ HEXA_NS::Quad* next_q = NULL;
+ HEXA_NS::Edge* e = q->getEdge(i);
+ for ( int j=0 ; j < e->getNbrParents(); ++j ){
+ next_q = e->getParent(j);
+ if ( next_q == q ){
+ next_q = NULL;
+ }
+ int fromSkin = std::count( skinQuad.begin(), skinQuad.end(), next_q );
+ if (fromSkin != 0){
+ int fromWorkingQuad = std::count( workingQuad.begin(), workingQuad.end(), next_q );
+ if ( fromWorkingQuad == 0 ){
+ workingQuad.push_front( next_q );
+ }
+ }
+ }
+ }
+
+ // setting quad way
+ HEXA_NS::Edge* e0 = q->getEdge(0);
+ HEXA_NS::Vertex* e0_0 = e0->getVertex(0);
+
+ if ( e0_0 == localEdgeWays[ e0 ].first ){
+ quadWays[q] = true;
+ } else if ( e0_0 == localEdgeWays[ e0 ].second ){
+ quadWays[q] = false;
+ } else {
+ ASSERT(false);
+ }
+ workingQuad.remove( q );
+ skinQuad.remove( q );
+ q = workingQuad.back();
+ }
+ }
+
+ return quadWays;
+}
+
+
+
+
+
+// std::map<HEXA_NS::Quad*, bool> SMESH_HexaBlocks::computeQuadWays( HEXA_NS::Document& doc, std::map<HEXA_NS::Quad*, bool> initQuads )
+// {
+// std::map<HEXA_NS::Quad*, bool> quadWays;
+// // std::map<HEXA_NS::Edge*, bool> edgeWays;
+// // std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > edgeWays;
+// std::map<HEXA_NS::Quad*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > workingQuads;
+//
+// std::list<HEXA_NS::Quad*> skinQuad;
+// std::list<HEXA_NS::Quad*> notSkinQuad;
+// // std::list<HEXA_NS::Quad*> workingQuad;
+// HEXA_NS::Quad* first_q = NULL;
+// HEXA_NS::Quad* q = NULL;
+// HEXA_NS::Edge* e = NULL;
+// HEXA_NS::Vertex *e_0, *e_1 = NULL;
+//
+// // FIRST STEP: eliminate free quad + internal quad
+// int nTotalQuad = doc.countQuad();
+// for (int i=0; i < nTotalQuad; ++i ){
+// q = doc.getQuad(i);
+// switch ( q->getNbrParents() ){ // parent == hexaedron
+// case 0: case 2: quadWays[q] = true; break;
+// // case 0: case 2: notSkinQuad.push_back(q); break; //CS_TEST
+// case 1: skinQuad.push_back(q); break;
+// default: if ( q->getNbrParents() > 2 ) ASSERT(false);
+// }
+// }
+//
+//
+// // SECOND STEP
+// q = first_q = skinQuad.front();
+// e = q->getUsedEdge(0);
+// e_0 = e->getVertex(0);
+// e_1 = e->getVertex(1);
+//
+// workingQuads[q] = std::make_pair( e_0, e_1 );
+//
+// while ( workingQuads.size() > 0 ){
+// MESSAGE("CURRENT QUAD ------>"<< q->getId());
+// HEXA_NS::Vertex *lastVertex=NULL, *firstVertex = NULL;
+// int i = 0;
+//
+// std::map<HEXA_NS::Edge*, std::pair<HEXA_NS::Vertex*, HEXA_NS::Vertex*> > localEdgeWays;
+// while ( localEdgeWays.size() != 4 ){
+// HEXA_NS::Edge* e = q->getUsedEdge(i%4);
+// if ( lastVertex == NULL ){
+// HEXA_NS::Vertex* e_0 = e->getVertex(0);
+// HEXA_NS::Vertex* e_1 = e->getVertex(1);
+//
+// if ( (workingQuads[q].first == e_0 and workingQuads[q].second == e_1)
+// or (workingQuads[q].first == e_1 and workingQuads[q].second == e_0) ){
+// if ( q == first_q ){
+// localEdgeWays[e] = std::make_pair( workingQuads[q].first, workingQuads[q].second );
+// MESSAGE("FIRST QUAD ");
+// } else {
+// localEdgeWays[e] = std::make_pair( workingQuads[q].second, workingQuads[q].first);
+// MESSAGE("NOT FIRST QUAD ");
+// }
+// firstVertex = localEdgeWays[e].first;
+// lastVertex = localEdgeWays[e].second;
+// }
+// } else {
+// HEXA_NS::Vertex* e_0 = e->getVertex(0);
+// HEXA_NS::Vertex* e_1 = e->getVertex(1);
+// if ( lastVertex == e_0 ){
+// localEdgeWays[e] = std::make_pair( e_0, e_1 );
+// firstVertex = e_0;
+// lastVertex = e_1;
+// } else if ( lastVertex == e_1 ){
+// localEdgeWays[e] = std::make_pair( e_1, e_0 );
+// firstVertex = e_1;
+// lastVertex = e_0;
+// } else if ( firstVertex == e_0 ) {
+// localEdgeWays[e] = std::make_pair( e_1, e_0 );
+// firstVertex = e_1;
+// lastVertex = e_0;
+// } else if ( firstVertex == e_1 ) {
+// localEdgeWays[e] = std::make_pair( e_0, e_1 );
+// firstVertex = e_0;
+// lastVertex = e_1;
+// } else {
+// ASSERT(false);
+// }
+// }
+// ++i;
+// }
+//
+//
+// //add new working quad
+// for ( int i=0 ; i < 4; ++i ){
+// HEXA_NS::Quad* next_q = NULL;
+// HEXA_NS::Edge* e = q->getUsedEdge(i);
+// MESSAGE("NB PARENTS ="<< e->getNbrParents() );
+// for ( int j=0 ; j < e->getNbrParents(); ++j ){
+// next_q = e->getParent(j);
+// if ( next_q == q ){
+// next_q = NULL;
+// }
+// int fromSkin = std::count( skinQuad.begin(), skinQuad.end(), next_q );
+// if (fromSkin != 0){
+// // int fromWorkingQuad = std::count( workingQuads.begin(), workingQuads.end(), next_q );
+// int fromWorkingQuad = workingQuads.count( next_q );
+// // MESSAGE("CHECK QUAD:"<< newWorkingQuad->getId());
+// if ( fromWorkingQuad == 0 ){
+// // workingQuads.push_front( next_q );
+// workingQuads[ next_q ] = localEdgeWays[e];
+// // MESSAGE("EDGE :"<<e->getId()<<"ADD QUAD :"<< newWorkingQuad->getId());
+// }
+// }
+// }
+// }
+//
+// //setting quad way
+// HEXA_NS::Edge* e0 = q->getUsedEdge(0);
+// HEXA_NS::Vertex* e0_0 = e0->getVertex(0);
+//
+// if ( e0_0 == localEdgeWays[ e0 ].first ){
+// quadWays[q] = true;
+// } else if ( e0_0 == localEdgeWays[ e0 ].second ){
+// quadWays[q] = false;
+// } else {
+// ASSERT(false);
+// }
+// MESSAGE("quadWays ID ="<< q->getId() << ", WAY = " << quadWays[q] );
+//
+// // workingQuad.remove( q );
+// workingQuads.erase( q );
+// skinQuad.remove( q );
+// *workingQuads.begin();
+// q = (*workingQuads.begin()).first;
+// }
+// return quadWays;
+// }
+
+
+bool SMESH_HexaBlocks::computeQuad( HEXA_NS::Quad& quad, bool way )
+{
+ bool ok = false;
+
+ ok = computeQuadByAssoc(quad, way);
+ if ( ok == false ){
+ ok = computeQuadByFindingGeom(quad, way);
+ }
+ if ( ok == false ){
+ ok = computeQuadByLinearApproximation(quad, way);
+ }
+ if (ok == true){
+ _computeQuadOK = true;
+ }
+ return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeQuadByAssoc( HEXA_NS::Quad& quad, bool way )
+{
+// int id = quad.getId();
+// if ( id != 11 ) return false; //7
+ if (MYDEBUG){
+ MESSAGE("computeQuadByLinearApproximation() : : begin <<<<<<");
+ MESSAGE("quadID = "<<quad.getId());
+ }
+ ASSERT( _computeEdgeOK );
+ bool ok = true;
+
+ ArrayOfSMESHNodes nodesOnQuad; // nodes in this quad ( to be added on the mesh )
+ SMESHFaces facesOnQuad;
+ SMDS_MeshFace* newFace = NULL;
+ std::vector<double> xx, yy;
+
+ // Elements for quad computation
+ SMDS_MeshNode *S1, *S2, *S4, *S3;
+
+// bool initOk = _computeQuadInit( quad, eh, eb, eg, ed, S1, S2, S3, S4 );
+ bool initOk = _computeQuadInit( quad, nodesOnQuad, xx, yy );
+ if ( initOk == false ){
+ return false;
+ }
+
+ const std::vector <HEXA_NS::Shape*> shapes = quad.getAssociations();
+ if ( shapes.size() == 0 ){
+ if(MYDEBUG) MESSAGE("computeQuadByAssoc() : end >>>>>>>>");
+ return false;
+ }
+ TopoDS_Shape shapeOrCompound = _getShapeOrCompound( shapes );
+// bool quadWay = _computeQuadWay( quad, S1, S2, S3, S4, &shapeOrCompound );
+// bool quadWay = _computeQuadWay( quad );
+
+
+ std::map<SMDS_MeshNode*, gp_Pnt> interpolatedPoints;
+ int iSize = nodesOnQuad.size();
+ int jSize = nodesOnQuad[0].size();
+
+ S1 = nodesOnQuad[0][0];
+// S2 = nodesOnQuad[bNodes.size()-1][0];
+ S2 = nodesOnQuad[iSize-1][0];
+ S4 = nodesOnQuad[0][jSize-1];
+ S3 = nodesOnQuad[iSize-1][jSize-1];
+
+
+ for (int j = 1; j < jSize; ++j){
+ for (int i = 1; i < iSize; ++i){
+ SMDS_MeshNode* n1 = nodesOnQuad[i-1][j];
+ SMDS_MeshNode* n2 = nodesOnQuad[i-1][j-1];
+ SMDS_MeshNode* n3 = nodesOnQuad[i][j-1];
+ SMDS_MeshNode* n4 = nodesOnQuad[i][j];
+
+ if ( n4 == NULL ){
+ double newNodeX, newNodeY, newNodeZ;
+ SMDS_MeshNode* Ph = nodesOnQuad[i][jSize-1]; //dNodes[h_i];
+ SMDS_MeshNode* Pb = nodesOnQuad[i][0]; //bNodes[b_i];
+ SMDS_MeshNode* Pg = nodesOnQuad[0][j]; //gNodes[g_j];
+ SMDS_MeshNode* Pd = nodesOnQuad[iSize-1][j]; //dNodes[d_j];
+ double u = xx[i];
+ double v = yy[j];
+
+ _nodeInterpolationUV(u, v, Pg, Pd, Ph, Pb, S1, S2, S3, S4, newNodeX, newNodeY, newNodeZ);
+ gp_Pnt newPt = gp_Pnt( newNodeX, newNodeY, newNodeZ );//interpolated point
+ gp_Pnt pt1;
+ gp_Pnt pt3;
+ if ( interpolatedPoints.count(n1) > 0 ){
+ pt1 = interpolatedPoints[n1];
+ } else {
+ pt1 = gp_Pnt( n1->X(), n1->Y(), n1->Z() );
+ }
+ if ( interpolatedPoints.count(n3) > 0 ){
+ pt3 = interpolatedPoints[n3];
+ } else {
+ pt3 = gp_Pnt( n3->X(), n3->Y(), n3->Z() );
+ }
+ gp_Vec vec1( newPt, pt1 );
+ gp_Vec vec2( newPt, pt3 );
+
+ gp_Pnt ptOnShape = _intersect(newPt, vec1, vec2, shapeOrCompound);
+ newNodeX = ptOnShape.X();
+ newNodeY = ptOnShape.Y();
+ newNodeZ = ptOnShape.Z();
+ n4 = _theMeshDS->AddNode( newNodeX, newNodeY, newNodeZ );
+ nodesOnQuad[i][j] = n4;
+ interpolatedPoints[ n4 ] = newPt;
+
+ if (MYDEBUG) {
+ MESSAGE("u parameter is "<<u);
+ MESSAGE("v parameter is "<<v);
+ MESSAGE("point interpolated ("<<newPt.X()<<","<<newPt.Y()<<","<<newPt.Z()<<" )");
+ MESSAGE("point on shape ("<<newNodeX<<","<<newNodeY<<","<<newNodeZ<<" )");
+ }
+ }
+
+ if (MYDEBUG){
+ MESSAGE("n1 (" << n1->X() << "," << n1->Y() << "," << n1->Z() << ")");
+ MESSAGE("n2 (" << n2->X() << "," << n2->Y() << "," << n2->Z() << ")");
+ MESSAGE("n4 (" << n4->X() << "," << n4->Y() << "," << n4->Z() << ")");
+ MESSAGE("n3 (" << n3->X() << "," << n3->Y() << "," << n3->Z() << ")");
+ }
+
+ if ( way == true ){
+ if (MYDEBUG) MESSAGE("AddFace( n1, n2, n3, n4 )");
+ newFace = _theMeshDS->AddFace( n1, n2, n3, n4 );
+ } else {
+ if (MYDEBUG) MESSAGE("AddFace( n4, n3, n2, n1 )");
+ newFace = _theMeshDS->AddFace( n4, n3, n2, n1 );
+ }
+ facesOnQuad.push_back(newFace);
+ }
+ }
+ _quadNodes[ &quad ] = nodesOnQuad;
+ _facesOnQuad[&quad] = facesOnQuad;
+
+ if(MYDEBUG) MESSAGE("computeQuadByLinearApproximation() : end >>>>>>>>");
+ return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeQuadByFindingGeom( HEXA_NS::Quad& quad, bool way )
+{
+ if(MYDEBUG) MESSAGE("computeQuadByFindingGeom() not implemented");
+ return false;
+}
+
+bool SMESH_HexaBlocks::_computeQuadInit(
+ HEXA_NS::Quad& quad,
+ ArrayOfSMESHNodes& nodesOnQuad,
+ std::vector<double>& xx, std::vector<double>& yy)
+{
+ if(MYDEBUG) MESSAGE("_computeQuadInit() : begin ---------------");
+ bool ok = true;
+
+ SMDS_MeshNode *S1, *S2, *S4, *S3;
+ HEXA_NS::Edge *eh, *eb, *eg, *ed;
+ HEXA_NS::Edge *e1, *e2, *e3, *e4;
+ HEXA_NS::Vertex *e1_0, *e1_1, *e2_0, *e2_1, *e3_0, *e3_1, *e4_0, *e4_1;
+
+ e1 = quad.getEdge(0);
+ e2 = quad.getEdge(1);
+ e3 = quad.getEdge(2);
+ e4 = quad.getEdge(3);
+
+ e1_0 = e1->getVertex(0); e1_1 = e1->getVertex(1);
+ e2_0 = e2->getVertex(0); e2_1 = e2->getVertex(1);
+ e3_0 = e3->getVertex(0); e3_1 = e3->getVertex(1);
+ e4_0 = e4->getVertex(0); e4_1 = e4->getVertex(1);
+
+ //S1, S2
+ S1 = _node[e1_0]; S2 = _node[e1_1];
+ eb = e1; eh = e3;
+ //S4
+ if ( e1_0 == e2_0 ){
+ S4 = _node[e2_1];
+ eg = e2; ed = e4;
+ } else if ( e1_0 == e2_1 ){
+ S4 = _node[e2_0];
+ eg = e2; ed = e4;
+ } else if ( e1_0 == e4_0 ){
+ S4 = _node[e4_1];
+ eg = e4; ed = e2;
+ } else if ( e1_0 == e4_1 ){
+ S4 = _node[e4_0];
+ eg = e4; ed = e2;
+ } else {
+ ASSERT(false);
+ }
+ //S3
+ if ( S4 == _node[e3_0] ){
+ S3 = _node[e3_1];
+ } else if ( S4 == _node[e3_1] ){
+ S3 = _node[e3_0];
+ } else {
+ ASSERT(false);
+ }
+
+ SMESHNodes hNodes = _nodesOnEdge[eh];
+ SMESHNodes bNodes = _nodesOnEdge[eb];
+ SMESHNodes gNodes = _nodesOnEdge[eg];
+ SMESHNodes dNodes = _nodesOnEdge[ed];
+ nodesOnQuad.resize( bNodes.size(), SMESHNodes(gNodes.size(), static_cast<SMDS_MeshNode*>(NULL)) );
+
+
+ int i, j, _i, _j;
+// int &b_i = i, &h_i = i, &g_j = j, &d_j = j;
+ int *b_i = &i, *h_i = &i, *g_j = &j, *d_j = &j;
+ bool uWay = true, vWay = true;
+
+ if ( bNodes[0] != S1 ){
+ b_i = &_i;
+ uWay = false;
+ ASSERT( bNodes[bNodes.size()-1] == S1 );
+ } else {
+ ASSERT( bNodes[0] == S1);
+ }
+ if ( hNodes[0] != S4 ){
+ h_i = &_i;
+ } else {
+ ASSERT( hNodes[0] == S4 );
+ }
+ if ( gNodes[0] != S1 ){
+ g_j = &_j;
+ vWay = false;
+ } else {
+ ASSERT( gNodes[0] == S1 );
+ }
+ if ( dNodes[0] != S2 ){
+ d_j = &_j;
+ } else {
+ ASSERT( dNodes[0] == S2 );
+ }
+
+ //bNodes, hNodes
+ double u;
+ for (i = 0, _i = bNodes.size()-1; i < bNodes.size(); ++i, --_i){
+ nodesOnQuad[i][0] = bNodes[*b_i];
+ nodesOnQuad[i][gNodes.size()-1 ] = hNodes[*h_i];
+
+ u = _nodeXx[ bNodes[*b_i] ];
+ if ( uWay == true ){
+ xx.push_back(u);
+ } else {
+ xx.push_back(1.-u);
+ }
+ }
+ if ( S1 != nodesOnQuad[0][0] ){
+ if(MYDEBUG) MESSAGE("ZZZZZZZZZZZZZZZZ quadID = "<<quad.getId());
+ }
+// ASSERT( S1 == nodesOnQuad[0][0] );
+
+ //gNodes, dNodes
+ double v;
+ for (j = 0, _j = gNodes.size()-1; j < gNodes.size(); ++j, --_j){
+ nodesOnQuad[0][j] = gNodes[*g_j];
+ if ( S1 != nodesOnQuad[0][0] ){
+ if(MYDEBUG) MESSAGE("XXXXXXXXXXXXXXXX quadID = "<<quad.getId());
+ }
+// ASSERT( S1 == nodesOnQuad[0][0] );
+ nodesOnQuad[bNodes.size()-1][j] = dNodes[*d_j];
+ v = _nodeXx[ gNodes[*g_j] ];
+ if ( vWay == true ){
+ yy.push_back(v);
+ } else {
+ yy.push_back(1.-v);
+ }
+ }
+
+
+ int iSize = nodesOnQuad.size();
+ int jSize = nodesOnQuad[0].size();
+ ASSERT( iSize = bNodes.size() );
+ ASSERT( jSize = gNodes.size() );
+
+// ASSERT( S1 == nodesOnQuad[0][0] );
+// ASSERT( S2 == nodesOnQuad[iSize-1][0]);
+// ASSERT( S4 == nodesOnQuad[0][jSize-1]);
+// ASSERT( S3 == nodesOnQuad[iSize-1][jSize-1]);
+
+ return ok;
+}
+
+
+bool SMESH_HexaBlocks::computeQuadByLinearApproximation( HEXA_NS::Quad& quad, bool way )
+{
+// int id = quad.getId();
+// if ( quad.getId() != 66 ) return false; //7, 41
+ if (MYDEBUG){
+ MESSAGE("computeQuadByLinearApproximation() : : begin <<<<<<");
+ MESSAGE("quadID = "<<quad.getId());
+ }
+ ASSERT( _computeEdgeOK );
+ bool ok = true;
+
+ ArrayOfSMESHNodes nodesOnQuad; // nodes in this quad ( to be added on the mesh )
+ SMESHFaces facesOnQuad;
+ SMDS_MeshFace* newFace = NULL;
+ std::vector<double> xx, yy;
+
+ // Elements for quad computation
+ SMDS_MeshNode *S1, *S2, *S4, *S3;
+
+// bool initOk = _computeQuadInit( quad, eh, eb, eg, ed, S1, S2, S3, S4 );
+ bool initOk = _computeQuadInit( quad, nodesOnQuad, xx, yy );
+ if ( initOk == false ){
+ return false;
+ }
+
+ int iSize = nodesOnQuad.size();
+ int jSize = nodesOnQuad[0].size();
+
+ S1 = nodesOnQuad[0][0];
+// S2 = nodesOnQuad[bNodes.size()-1][0];
+ S2 = nodesOnQuad[iSize-1][0];
+ S4 = nodesOnQuad[0][jSize-1];
+ S3 = nodesOnQuad[iSize-1][jSize-1];
+
+ for (int j = 1; j < jSize; ++j){
+ for (int i = 1; i < iSize; ++i){
+ SMDS_MeshNode* n1 = nodesOnQuad[i-1][j];
+ SMDS_MeshNode* n2 = nodesOnQuad[i-1][j-1];
+ SMDS_MeshNode* n3 = nodesOnQuad[i][j-1];
+ SMDS_MeshNode* n4 = nodesOnQuad[i][j];
+
+ if ( n4 == NULL ){
+ double newNodeX, newNodeY, newNodeZ;
+ SMDS_MeshNode* Ph = nodesOnQuad[i][jSize-1]; //dNodes[h_i];
+ SMDS_MeshNode* Pb = nodesOnQuad[i][0]; //bNodes[b_i];
+ SMDS_MeshNode* Pg = nodesOnQuad[0][j]; //gNodes[g_j];
+ SMDS_MeshNode* Pd = nodesOnQuad[iSize-1][j]; //dNodes[d_j];
+ double u = xx[i];
+ double v = yy[j];
+
+ _nodeInterpolationUV(u, v, Pg, Pd, Ph, Pb, S1, S2, S3, S4, newNodeX, newNodeY, newNodeZ);
+ n4 = _theMeshDS->AddNode( newNodeX, newNodeY, newNodeZ );
+ nodesOnQuad[i][j] = n4;
+ }
+
+ if (MYDEBUG){
+ MESSAGE("n1 (" << n1->X() << "," << n1->Y() << "," << n1->Z() << ")");
+ MESSAGE("n2 (" << n2->X() << "," << n2->Y() << "," << n2->Z() << ")");
+ MESSAGE("n4 (" << n4->X() << "," << n4->Y() << "," << n4->Z() << ")");
+ MESSAGE("n3 (" << n3->X() << "," << n3->Y() << "," << n3->Z() << ")");
+ }
+
+ if ( way == true ){
+ if (MYDEBUG) MESSAGE("AddFace( n1, n2, n3, n4 )");
+ newFace = _theMeshDS->AddFace( n1, n2, n3, n4 );
+ } else {
+ if (MYDEBUG) MESSAGE("AddFace( n4, n3, n2, n1 )");
+ newFace = _theMeshDS->AddFace( n4, n3, n2, n1 );
+ }
+ facesOnQuad.push_back(newFace);
+ }
+ }
+ _quadNodes[ &quad ] = nodesOnQuad;
+ _facesOnQuad[&quad] = facesOnQuad;
+
+ if(MYDEBUG) MESSAGE("computeQuadByLinearApproximation() : end >>>>>>>>");
+ return ok;
+}
+
+
+// --------------------------------------------------------------
+// Hexa computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeHexa( HEXA_NS::Document* doc )
+{
+ if(MYDEBUG) MESSAGE("computeHexa() : : begin <<<<<<");
+ bool ok=false;
+
+ SMESH_MesherHelper aHelper(*_theMesh);
+ TopoDS_Shape shape = _theMesh->GetShapeToMesh();
+ aHelper.SetSubShape( shape );
+ aHelper.SetElementsOnShape( true );
+
+ SMESH_Gen* gen = _theMesh->GetGen();
+ SMESH_HexaFromSkin_3D algo( gen->GetANewId(), 0, gen, doc );
+ algo.InitComputeError();
+ try {
+ ok = algo.Compute( *_theMesh, &aHelper, _volumesOnHexa, _node );
+ } catch(...) {
+ if(MYDEBUG) MESSAGE("SMESH_HexaFromSkin_3D error!!! ");
+ }
+ if (MYDEBUG){
+ MESSAGE("SMESH_HexaFromSkin_3D.comment = "<<algo.GetComputeError()->myComment);
+ MESSAGE("computeHexa() : end >>>>>>>>");
+ }
+ return ok;
+}
+
+
+
+// --------------------------------------------------------------
+// Document computing
+// --------------------------------------------------------------
+bool SMESH_HexaBlocks::computeDoc( HEXA_NS::Document* doc )
+{
+ if(MYDEBUG) MESSAGE("computeDoc() : : begin <<<<<<");
+ bool ok = true;
+
+ // A) Vertex computation
+
+ int nVertex = doc->countUsedVertex();
+ HEXA_NS::Vertex* vertex = NULL;
+
+ for (int j=0; j <nVertex; ++j ){ //Computing each vertex of the document
+ vertex = doc->getUsedVertex(j);
+ ok = computeVertex(*vertex);
+ }
+
+ // B) Edges computation
+ int nbPropa = 0;
+ HEXA_NS::Propagation* propa = NULL;
+ HEXA_NS::Law* law = NULL;
+ HEXA_NS::Edges edges;
+
+ nbPropa = doc->countPropagation();
+ for (int j=0; j < nbPropa; ++j ){//Computing each edge's propagations of the document
+ propa = doc->getPropagation(j);
+ edges = propa->getEdges();
+ law = propa->getLaw();
+// ASSERT( law );
+ if (law == NULL){
+ law = doc->getLaw(0); // default law
+ }
+ for( HEXA_NS::Edges::const_iterator iter = edges.begin();
+ iter != edges.end();
+ ++iter ){
+ ok = computeEdge(**iter, *law);
+ }
+ }
+ // C) Quad computation
+ std::map<HEXA_NS::Quad*, bool> quadWays = computeQuadWays(doc);
+ int nQuad = doc->countUsedQuad();
+ HEXA_NS::Quad* q = NULL;
+ for (int j=0; j <nQuad; ++j ){ //Computing each quad of the document
+ q = doc->getUsedQuad(j);
+ int id = q->getId();
+ if ( quadWays.count(q) > 0 )
+ ok = computeQuad( *q, quadWays[q] );
+ else
+ if(MYDEBUG) MESSAGE("NO QUAD WAY ID = "<<id);
+
+ }
+
+ // D) Hexa computation: Calling HexaFromSkin algo
+ ok = computeHexa(doc);
+
+ if(MYDEBUG) MESSAGE("computeDoc() : end >>>>>>>>");
+ return ok;
+}
+
+
+void SMESH_HexaBlocks::buildGroups(HEXA_NS::Document* doc)
+{
+ if (MYDEBUG){
+ MESSAGE("_addGroups() : : begin <<<<<<");
+ MESSAGE("_addGroups() : : nb. hexas= " << doc->countUsedHexa());
+ MESSAGE("_addGroups() : : nb. quads= " << doc->countUsedQuad());
+ MESSAGE("_addGroups() : : nb. edges= " << doc->countUsedEdge());
+ MESSAGE("_addGroups() : : nb. nodes= " << doc->countUsedVertex());
+ }
+ // Looping on each groups of the document
+ for ( int i=0; i < doc->countGroup(); i++ ){
+ _fillGroup( doc->getGroup(i) );
+ };
+
+ if(MYDEBUG) MESSAGE("_addGroups() : end >>>>>>>>");
+}
+
+// --------------------------------------------------------------
+// PRIVATE METHODS
+// --------------------------------------------------------------
+double SMESH_HexaBlocks::_Xx( double i, HEXA_NS::Law law, double nbNodes) //, double pos0 )
+{
+ double result;
+ double u0;
+
+ HEXA_NS::KindLaw k = law.getKind();
+ double coeff = law.getCoefficient();
+ switch (k){
+ case HEXA_NS::Uniform:
+ result = (i+1)/(nbNodes+1);
+ if(MYDEBUG) MESSAGE( "_Xx():" << " Uniform u("<<i<< ")"<< " = " << result);
+ break;
+ case HEXA_NS::Arithmetic:
+ u0 = 1./(nbNodes + 1.) - (coeff*nbNodes)/2.;
+// ASSERT(u0>0);
+ if ( u0 <= 0 ) throw (SALOME_Exception(LOCALIZED("Arithmetic discretization : check coefficient")));
+ if (i==0){
+ result = u0;
+ } else {
+ result = (i + 1.)*u0 + coeff*i*(i+1.)/2.;
+ };
+ if(MYDEBUG) MESSAGE( "_Xx():" << " Arithmetic u("<<i<< ")"<< " = " << result);
+ break;
+ case HEXA_NS::Geometric:
+ u0 = (1.-coeff)/(1.-pow(coeff, nbNodes + 1) ) ;
+// ASSERT(u0>0);
+ if ( u0 <= 0 ) throw (SALOME_Exception(LOCALIZED("Geometric discretization : check coefficient")));
+ if (i==0){
+ result = u0;
+ } else {
+ result = u0 * (1.- pow(coeff, i + 1) )/(1.-coeff) ;
+ };
+ if(MYDEBUG) MESSAGE( "_Xx():" << " Geometric u("<<i<< ")"<< " = " << result);
+ break;
+ }
+ return result;
+}
+
+
+double SMESH_HexaBlocks::_edgeLength(const TopoDS_Edge & E)
+{
+ if(MYDEBUG) MESSAGE("_edgeLength() : : begin <<<<<<");
+ double UMin = 0, UMax = 0;
+ if (BRep_Tool::Degenerated(E))
+ return 0;
+ TopLoc_Location L;
+ Handle(Geom_Curve) C = BRep_Tool::Curve(E, L, UMin, UMax);
+ GeomAdaptor_Curve AdaptCurve(C);
+ double length = GCPnts_AbscissaPoint::Length(AdaptCurve, UMin, UMax);
+ if(MYDEBUG) MESSAGE("_edgeLength() : end >>>>>>>>");
+ return length;
+}
+
+
+void SMESH_HexaBlocks::_buildMyCurve(
+ const std::vector <HEXA_NS::Shape*>& associations, //IN
+ const gp_Pnt& myCurve_start, //IN
+ const gp_Pnt& myCurve_end, //IN
+ std::list< BRepAdaptor_Curve* >& myCurve, //INOUT
+ double& myCurve_length, //INOUT
+ std::map< BRepAdaptor_Curve*, double>& myCurve_lengths,//INOUT
+ std::map< BRepAdaptor_Curve*, bool>& myCurve_ways, //INOUT
+ std::map< BRepAdaptor_Curve*, double>& myCurve_starts, //INOUT
+ HEXA_NS::Edge& edge) // For error diagnostic
+{
+ if(MYDEBUG) MESSAGE("_buildMyCurve() : : begin <<<<<<");
+ bool myCurve_way = true;
+ myCurve_length = 0.;
+ BRepAdaptor_Curve* thePreviousCurve = NULL;
+ BRepAdaptor_Curve* theCurve = NULL;
+
+ gp_Pnt theCurve_start, theCurve_end;
+ gp_Pnt thePreviousCurve_start , thePreviousCurve_end;
+
+ for ( std::vector <HEXA_NS::Shape*> ::const_iterator assoc = associations.begin();
+ assoc != associations.end();
+ ++assoc ){
+ string theBrep = (*assoc)->getBrep();
+ double ass_debut = std::min ((*assoc)->debut, (*assoc)->fin);
+ double ass_fin = std::max ((*assoc)->debut, (*assoc)->fin);
+ TopoDS_Shape theShape = string2shape( theBrep );
+ TopoDS_Edge theEdge = TopoDS::Edge( theShape );
+ double theCurve_length = _edgeLength( theEdge );
+ if (MYDEBUG)
+ MESSAGE("_edgeLength ->"<<theCurve_length);
+
+ if ( theCurve_length > 0 ){
+ double f, l;
+ Handle(Geom_Curve) testCurve = BRep_Tool::Curve(theEdge, f, l);
+ theCurve = new BRepAdaptor_Curve( theEdge );
+
+ GCPnts_AbscissaPoint discret_start (*theCurve,
+ theCurve_length*ass_debut,
+ theCurve->FirstParameter() );
+ GCPnts_AbscissaPoint discret_end (*theCurve,
+ theCurve_length*ass_fin,
+ theCurve->FirstParameter() );
+ double u_start = discret_start.Parameter();
+ double u_end = discret_end.Parameter();
+ ASSERT( discret_start.IsDone() && discret_end.IsDone() );
+ theCurve_start = theCurve->Value( u_start);
+ theCurve_end = theCurve->Value( u_end );
+ theCurve_length = theCurve_length*( ass_fin - ass_debut);
+
+ if (MYDEBUG){
+ MESSAGE("testCurve->f ->"<<f);
+ MESSAGE("testCurve->l ->"<<l);
+ MESSAGE("testCurve->FirstParameter ->"<<testCurve->FirstParameter());
+ MESSAGE("testCurve->LastParameter ->"<<testCurve->LastParameter());
+
+ MESSAGE("FirstParameter ->"<<theCurve->FirstParameter());
+ MESSAGE("LastParameter ->"<<theCurve->LastParameter());
+ MESSAGE("theCurve_length ->"<<theCurve_length);
+ MESSAGE("(*assoc)->debut ->"<< ass_debut );
+ MESSAGE("(*assoc)->fin ->"<< ass_fin );
+ MESSAGE("u_start ->"<<u_start);
+ MESSAGE("u_end ->"<<u_end);
+ MESSAGE("myCurve_start( "<<myCurve_start.X()<<", "<<myCurve_start.Y()<<", "<<myCurve_start.Z()<<") ");
+ MESSAGE("theCurve_start( "<<theCurve_start.X()<<", "<<theCurve_start.Y()<<", "<<theCurve_start.Z()<<") ");
+ MESSAGE("myCurve_end( "<<myCurve_end.X()<<", "<<myCurve_end.Y()<<", "<<myCurve_end.Z()<<") ");
+ MESSAGE("theCurve_end( "<<theCurve_end.X()<<", "<<theCurve_end.Y()<<", "<<theCurve_end.Z()<<") ");
+ }
+
+ if ( thePreviousCurve == NULL ){
+ // setting myCurve_way and first curve way
+ if ( myCurve_start.IsEqual(theCurve_start, HEXA_EPSILON) ){
+ if(MYDEBUG) MESSAGE("myCurve_start.IsEqual(theCurve_start, HEXA_EPSILON)");
+ myCurve_way = true;
+ myCurve_ways[theCurve] = true;
+ } else if ( myCurve_start.IsEqual(theCurve_end, HEXA_EPSILON) ){
+ if(MYDEBUG) MESSAGE("myCurve_start.IsEqual(theCurve_end, HEXA_EPSILON)");
+ myCurve_way = true;
+ myCurve_ways[theCurve] = false;
+ } else if ( myCurve_end.IsEqual(theCurve_end, HEXA_EPSILON) ){
+ if(MYDEBUG) MESSAGE("myCurve_end.IsEqual(theCurve_end, HEXA_EPSILON)");
+ myCurve_way = false;
+ myCurve_ways[theCurve] = true;
+ } else if ( myCurve_end.IsEqual(theCurve_start, HEXA_EPSILON) ){
+ if(MYDEBUG) MESSAGE("myCurve_end.IsEqual(theCurve_start, HEXA_EPSILON)");
+ myCurve_way = false;
+ myCurve_ways[theCurve] = false;
+ } else {
+ if(MYDEBUG) MESSAGE("SOMETHING WRONG on edge association... Bad script?");
+// ASSERT(false);
+ edge.dumpAsso();
+ throw (SALOME_Exception(LOCALIZED("Edge association : check association parameters ( first, last ) between HEXA model and CAO")));
+ }
+
+ } else {
+ // it is not the first or last curve.
+ // ways are calculated between previous and new one.
+ if ( thePreviousCurve_end.IsEqual( theCurve_end, HEXA_EPSILON )
+ or thePreviousCurve_start.IsEqual( theCurve_start, HEXA_EPSILON ) ){
+ myCurve_ways[theCurve] = !myCurve_ways[thePreviousCurve];// opposite WAY
+ if(MYDEBUG) MESSAGE("opposite WAY");
+ } else if ( thePreviousCurve_end.IsEqual( theCurve_start, HEXA_EPSILON )
+ or thePreviousCurve_start.IsEqual( theCurve_end, HEXA_EPSILON ) ){
+ myCurve_ways[theCurve] = myCurve_ways[thePreviousCurve];// same WAY
+ if(MYDEBUG) MESSAGE("same WAY");
+ } else {
+ if(MYDEBUG) MESSAGE("SOMETHING WRONG on edge association... bad script?");
+// ASSERT(false);
+ throw (SALOME_Exception(LOCALIZED("Edge association : Check association parameters ( first, last ) between HEXA model and CAO")));
+ }
+ }
+
+ myCurve_starts[theCurve] = u_start;
+ myCurve_lengths[theCurve] = theCurve_length;
+ myCurve_length += theCurve_length;
+ myCurve.push_back( theCurve );
+
+ thePreviousCurve = theCurve;
+ thePreviousCurve_start = theCurve_start;
+ thePreviousCurve_end = theCurve_end;
+
+ }//if ( theCurveLength > 0 ){
+
+ }// for
+
+
+ if ( myCurve_way == false ){
+ std::list< BRepAdaptor_Curve* > tmp( myCurve.size() );
+ std::copy( myCurve.rbegin(), myCurve.rend(), tmp.begin() );
+ myCurve = tmp;
+ }
+
+ if (MYDEBUG) {
+ MESSAGE("myCurve_way was :"<<myCurve_way);
+ MESSAGE("_buildMyCurve() : end >>>>>>>>");
+ }
+}
+
+
+
+
+gp_Pnt SMESH_HexaBlocks::_getPtOnMyCurve(
+ const double& myCurve_u, //IN
+ std::map< BRepAdaptor_Curve*, bool>& myCurve_ways, //IN
+ std::map< BRepAdaptor_Curve*, double>& myCurve_lengths,//IN
+ std::map< BRepAdaptor_Curve*, double>& myCurve_starts, //IN
+ std::list< BRepAdaptor_Curve* >& myCurve, //INOUT
+ double& myCurve_start ) //INOUT
+// std::map< BRepAdaptor_Curve*, double>& myCurve_firsts,
+// std::map< BRepAdaptor_Curve*, double>& myCurve_lasts,
+{
+ if(MYDEBUG) MESSAGE("_getPtOnMyCurve() : : begin <<<<<<");
+ gp_Pnt ptOnMyCurve;
+
+ // looking for curve which contains parameter myCurve_u
+ BRepAdaptor_Curve* curve = myCurve.front();
+ double curve_start = myCurve_start;
+ double curve_end = curve_start + myCurve_lengths[curve];
+ double curve_u;
+ GCPnts_AbscissaPoint discret;
+
+ if (MYDEBUG){
+ MESSAGE("looking for curve: c = "<<myCurve_u);
+ MESSAGE("looking for curve: curve_start = "<<curve_start);
+ MESSAGE("looking for curve: curve_end = "<<curve_end);
+ MESSAGE("looking for curve: curve_lenght = "<<myCurve_lengths[curve]);
+ MESSAGE("looking for curve: curve.size _lenght= "<<myCurve.size());
+ }
+ while ( not ( (myCurve_u >= curve_start) and (myCurve_u <= curve_end) ) ) {
+ // if (myCurve.size() == 0 )
+ // {
+ // PutData (myCurve.size());
+ // PutData (myCurve_u);
+ // }
+
+ ASSERT( myCurve.size() != 0 );
+ myCurve.pop_front();
+ curve = myCurve.front();
+ curve_start = curve_end;
+ curve_end = curve_start + myCurve_lengths[curve];
+ if (MYDEBUG){
+ MESSAGE("go next curve: curve_lenght = "<<myCurve_lengths[curve]);
+ MESSAGE("go next curve: curve_start = "<<curve_start);
+ MESSAGE("go next curve: curve_end = "<<curve_end);
+ MESSAGE("go next curve: myCurve_u = "<<myCurve_u);
+ }
+ }
+ myCurve_start = curve_start;
+
+ // compute point
+ if ( myCurve_ways[curve] ){
+// curve_u = myCurve_firsts[curve] + (myCurve_u - curve_start);
+// discret = GCPnts_AbscissaPoint( *curve, (myCurve_u - curve_start), curve->FirstParameter() );
+ discret = GCPnts_AbscissaPoint( *curve, (myCurve_u - curve_start), myCurve_starts[curve] );
+ } else {
+// discret = GCPnts_AbscissaPoint( *curve, myCurve_lengths[curve]- (myCurve_u - curve_start), curve->FirstParameter() );
+ discret = GCPnts_AbscissaPoint( *curve, myCurve_lengths[curve]- (myCurve_u - curve_start), myCurve_starts[curve] );
+ }
+ ASSERT(discret.IsDone());
+ curve_u = discret.Parameter();
+ ptOnMyCurve = curve->Value( curve_u );
+
+ if (MYDEBUG){
+ MESSAGE("curve found!");
+ MESSAGE("curve_u = "<< curve_u);
+ MESSAGE("curve way = "<< myCurve_ways[curve]);
+ MESSAGE("_getPtOnMyCurve() : end >>>>>>>>");
+ }
+ return ptOnMyCurve;
+}
+
+
+
+
+
+
+
+void SMESH_HexaBlocks::_nodeInterpolationUV(double u, double v,
+ SMDS_MeshNode* Pg, SMDS_MeshNode* Pd, SMDS_MeshNode* Ph, SMDS_MeshNode* Pb,
+ SMDS_MeshNode* S1, SMDS_MeshNode* S2, SMDS_MeshNode* S3, SMDS_MeshNode* S4,
+ double& xOut, double& yOut, double& zOut )
+{
+ if (MYDEBUG){
+ MESSAGE("_nodeInterpolationUV() IN:");
+ MESSAGE("u ( "<< u <<" )");
+ MESSAGE("v ( "<< v <<" )");
+
+ MESSAGE("S1 (" << S1->X() << "," << S1->Y() << "," << S1->Z() << ")");
+ MESSAGE("S2 (" << S2->X() << "," << S2->Y() << "," << S2->Z() << ")");
+ MESSAGE("S4 (" << S4->X() << "," << S4->Y() << "," << S4->Z() << ")");
+ MESSAGE("S3 (" << S3->X() << "," << S3->Y() << "," << S3->Z() << ")");
+
+ MESSAGE("Pg (" << Pg->X() << "," << Pg->Y() << "," << Pg->Z() << ")");
+ MESSAGE("Pd (" << Pd->X() << "," << Pd->Y() << "," << Pd->Z() << ")");
+ MESSAGE("Ph (" << Ph->X() << "," << Ph->Y() << "," << Ph->Z() << ")");
+ MESSAGE("Pb (" << Pb->X() << "," << Pb->Y() << "," << Pb->Z() << ")");
+ }
+
+ xOut = ((1.-u)*Pg->X() + v*Ph->X() + u*Pd->X() + (1.-v)*Pb->X()) - (1.-u)*(1.-v)*S1->X() - u*(1.-v)*S2->X() - u*v*S3->X() - (1.-u)*v*S4->X();
+ yOut = ((1.-u)*Pg->Y() + v*Ph->Y() + u*Pd->Y() + (1.-v)*Pb->Y()) - (1.-u)*(1.-v)*S1->Y() - u*(1.-v)*S2->Y() - u*v*S3->Y() - (1.-u)*v*S4->Y();
+ zOut = ((1.-u)*Pg->Z() + v*Ph->Z() + u*Pd->Z() + (1.-v)*Pb->Z()) - (1.-u)*(1.-v)*S1->Z() - u*(1.-v)*S2->Z() - u*v*S3->Z() - (1.-u)*v*S4->Z();
+
+ if (MYDEBUG){
+ MESSAGE("_nodeInterpolationUV() OUT("<<xOut<<","<<yOut<<","<<zOut<<" )");
+ }
+}
+
+
+TopoDS_Shape SMESH_HexaBlocks::_getShapeOrCompound( const std::vector<HEXA_NS::Shape*>& shapesIn)
+{
+ ASSERT( shapesIn.size()!=0 );
+
+ if (shapesIn.size() == 1) {
+ HEXA_NS::Shape* assoc = shapesIn.front();
+ string strBrep = assoc->getBrep();
+ return string2shape( strBrep );
+ } else {
+ TopoDS_Compound aCompound;
+ BRep_Builder aBuilder;
+ aBuilder.MakeCompound( aCompound );
+
+ for ( std::vector <HEXA_NS::Shape*> ::const_iterator assoc = shapesIn.begin();
+ assoc != shapesIn.end();
+ ++assoc ){
+ string strBrep = (*assoc)->getBrep();
+ TopoDS_Shape shape = string2shape( strBrep );
+ aBuilder.Add( aCompound, shape );
+ }
+ return aCompound;
+ }
+}
+
+
+// ================================================== carre
+inline double carre (double val)
+{
+ return val*val;
+}
+// ================================================== dist2
+inline double dist2 (const gp_Pnt& pt1, const gp_Pnt& pt2)
+{
+ double dist = carre (pt2.X()-pt1.X()) + carre (pt2.Y()-pt1.Y())
+ + carre (pt2.Z()-pt1.Z());
+ return dist;
+}
+// ================================================== _intersect
+gp_Pnt SMESH_HexaBlocks::_intersect( const gp_Pnt& Pt,
+ const gp_Vec& u, const gp_Vec& v,
+ const TopoDS_Shape& shape,
+ Standard_Real tol )
+{
+ gp_Pnt result;
+
+ gp_Vec normale = u^v;
+ gp_Dir dir(normale);
+ gp_Lin li( Pt, dir );
+
+ Standard_Real s = -Precision::Infinite();
+ Standard_Real e = +Precision::Infinite();
+
+ IntCurvesFace_ShapeIntersector inter;
+ inter.Load(shape, tol);
+// inter.Load(S, tol);
+ inter.Perform(li, s, e);//inter.PerformNearest(li, s, e);
+
+/************************************************************** Abu 2011-11-04 */
+ /// if ( inter.IsDone() && (inter.NbPnt()==1) ) {
+ if ( inter.IsDone() )
+ {
+ result = inter.Pnt(1);//first
+ int nbrpts = inter.NbPnt();
+ if (nbrpts>1)
+ {
+ double d0 = dist2 (result, Pt);
+ for (int i=2; i <= inter.NbPnt(); ++i )
+ {
+ double d1 = dist2 (Pt, inter.Pnt(i));
+ if (d1<d0)
+ {
+ d0 = d1;
+ result = inter.Pnt (i);
+ }
+ }
+ }
+/************************************************************** Abu 2011-11-04 (fin) */
+ if (MYDEBUG){
+ MESSAGE("_intersect() : OK");
+ for ( int i=1; i <= inter.NbPnt(); ++i ){
+ gp_Pnt tmp = inter.Pnt(i);
+ MESSAGE("_intersect() : pnt("<<i<<") = ("<<tmp.X()<<","<<tmp.Y()<<","<<tmp.Z()<<" )");
+ }
+ }
+ _found +=1;
+ } else {
+ if(MYDEBUG) MESSAGE("_intersect() : KO");
+ result = Pt;
+ _notFound +=1;
+ }
+ _total+=1;
+
+ return result;
+}
+
+// parameters q : IN, v0: INOUT, v1: INOUT
+void SMESH_HexaBlocks::_searchInitialQuadWay( HEXA_NS::Quad* q, HEXA_NS::Vertex*& v0, HEXA_NS::Vertex*& v1 )
+{
+ if(MYDEBUG) MESSAGE("_searchInitialQuadWay() : begin");
+ v0 = NULL; v1 = NULL;
+ if ( q->getNbrParents() != 1 ) return; // q must be a skin quad
+
+ HEXA_NS::Vertex* qA = q->getVertex(0);
+ HEXA_NS::Vertex* qB = q->getVertex(1);
+ HEXA_NS::Vertex* qC = q->getVertex(2);
+ HEXA_NS::Vertex* qD = q->getVertex(3);
+
+ // searching for vertex on opposed quad
+ HEXA_NS::Vertex *qAA = NULL, *qBB = NULL, *qCC = NULL, *qDD = NULL;
+ HEXA_NS::Hexa* h = q->getParent(0);
+ for( int i=0; i < h->countEdge(); ++i ){
+ HEXA_NS::Edge* e = h->getEdge(i);
+ HEXA_NS::Vertex* e0 = e->getVertex(0);
+ HEXA_NS::Vertex* e1 = e->getVertex(1);
+
+ if ( e0 == qA and e1 != qB and e1 != qC and e1 != qD ){
+ qAA = e1;
+ } else if ( e1 == qA and e0 != qB and e0 != qC and e0 != qD ){
+ qAA = e0;
+ } else if ( e0 == qB and e1 != qA and e1 != qC and e1 != qD ){
+ qBB = e1;
+ } else if ( e1 == qB and e0 != qA and e0 != qC and e0 != qD ){
+ qBB = e0;
+ } else if ( e0 == qC and e1 != qA and e1 != qB and e1 != qD ){
+ qCC = e1;
+ } else if ( e1 == qC and e0 != qA and e0 != qB and e0 != qD ){
+ qCC = e0;
+ } else if ( e0 == qD and e1 != qA and e1 != qB and e1 != qC ){
+ qDD = e1;
+ } else if ( e1 == qD and e0 != qA and e0 != qB and e0 != qC ){
+ qDD = e0;
+ }
+ }
+
+ // working on final value ( point on CAO ), not on model
+ SMDS_MeshNode *nA = _node[qA], *nAA = _node[qAA];
+ SMDS_MeshNode *nB = _node[qB], *nBB = _node[qBB];
+ SMDS_MeshNode *nC = _node[qC], *nCC = _node[qCC];
+ SMDS_MeshNode *nD = _node[qD], *nDD = _node[qDD];
+
+ gp_Pnt pA( nA->X(), nA->Y(), nA->Z() );
+ gp_Pnt pB( nB->X(), nB->Y(), nB->Z() );
+ gp_Pnt pC( nC->X(), nC->Y(), nC->Z() );
+ gp_Pnt pD( nD->X(), nD->Y(), nD->Z() );
+
+ gp_Pnt pAA( nAA->X(), nAA->Y(), nAA->Z() );
+ gp_Pnt pBB( nBB->X(), nBB->Y(), nBB->Z() );
+ gp_Pnt pCC( nCC->X(), nCC->Y(), nCC->Z() );
+ gp_Pnt pDD( nDD->X(), nDD->Y(), nDD->Z() );
+
+ gp_Vec AB( pA, pB );
+ gp_Vec AC( pA, pC );
+ gp_Vec normP = AB^AC;
+ gp_Dir dirP( normP );
+
+ // building plane for point projection
+ gp_Pln plnP( gp_Pnt(nA->X(), nA->Y(), nA->Z()), dirP);
+ TopoDS_Shape sPlnP = BRepBuilderAPI_MakeFace(plnP).Face();
+
+ // PAAA is the result of PAA projection
+ gp_Pnt pAAA = _intersect( pAA, AB, AC, sPlnP );
+ gp_Pnt pBBB = _intersect( pBB, AB, AC, sPlnP );
+ gp_Pnt pCCC = _intersect( pCC, AB, AC, sPlnP );
+ gp_Pnt pDDD = _intersect( pDD, AB, AC, sPlnP );
+
+ gp_Dir AA( gp_Vec(pAA, pAAA) );
+ gp_Dir BB( gp_Vec(pBB, pBBB) );
+ gp_Dir CC( gp_Vec(pCC, pCCC) );
+ gp_Dir DD( gp_Vec(pDD, pDDD) );
+
+ // eventually, we are able to know if the input quad is a good client!
+ // exit the fonction otherwise
+ if ( AA.IsOpposite(BB, HEXA_QUAD_WAY) ) return;
+ if ( BB.IsOpposite(CC, HEXA_QUAD_WAY) ) return;
+ if ( CC.IsOpposite(DD, HEXA_QUAD_WAY) ) return;
+
+ // ok, give the input quad the good orientation by
+ // setting 2 vertex
+ if ( !dirP.IsOpposite(AA, HEXA_QUAD_WAY) ) { //OK
+ v0 = qA; v1 = qB;
+ } else {
+ v0 = qB; v1 = qA;
+ }
+
+ if(MYDEBUG) MESSAGE("_searchInitialQuadWay() : end");
+}
+
+SMESH_Group* SMESH_HexaBlocks::_createGroup(HEXA_NS::Group& grHex)
+{
+ if(MYDEBUG) MESSAGE("_createGroup() : : begin <<<<<<");
+
+ std::string aGrName = grHex.getName();
+ HEXA_NS::EnumGroup grHexKind = grHex.getKind();
+
+ if(MYDEBUG) MESSAGE("aGrName"<<aGrName);
+
+ SMDSAbs_ElementType aGrType;
+ switch ( grHexKind ){
+ case HEXA_NS::HexaCell : aGrType = SMDSAbs_Volume; break;
+ case HEXA_NS::QuadCell : aGrType = SMDSAbs_Face ; break;
+ case HEXA_NS::EdgeCell : aGrType = SMDSAbs_Edge ; break;
+ case HEXA_NS::HexaNode : aGrType = SMDSAbs_Node ; break;
+ case HEXA_NS::QuadNode : aGrType = SMDSAbs_Node ; break;
+ case HEXA_NS::EdgeNode : aGrType = SMDSAbs_Node ; break;
+ case HEXA_NS::VertexNode : aGrType = SMDSAbs_Node ; break;
+ default : ASSERT(false);
+ }
+
+ int aId;
+ SMESH_Group* aGr = _theMesh->AddGroup(aGrType, aGrName.c_str(), aId);
+
+ if(MYDEBUG) MESSAGE("_createGroup() : end >>>>>>>>");
+ return aGr;
+}
+
+void SMESH_HexaBlocks::_fillGroup(HEXA_NS::Group* grHex )
+{
+ if(MYDEBUG) MESSAGE("_fillGroup() : : begin <<<<<<");
+
+ SMESH_Group* aGr = _createGroup( *grHex );
+ HEXA_NS::EltBase* grHexElt = NULL;
+ HEXA_NS::EnumGroup grHexKind = grHex->getKind();
+ int grHexNbElt = grHex->countElement();
+
+ if(MYDEBUG) MESSAGE("_fillGroup() : kind = " << grHexKind);
+ if(MYDEBUG) MESSAGE("_fillGroup() : count= " << grHexNbElt);
+
+ // A)Looking for elements ID
+ std::vector<const SMDS_MeshElement*> aGrEltIDs;
+
+ for ( int n=0; n<grHexNbElt; ++n ){
+ grHexElt = grHex->getElement(n);
+
+ switch ( grHexKind ){
+ case HEXA_NS::HexaCell:
+ {
+ HEXA_NS::Hexa* h = reinterpret_cast<HEXA_NS::Hexa*>(grHexElt);
+// HEXA_NS::Hexa* h = dynamic_cast<HEXA_NS::Hexa*>(grHexElt);
+// ASSERT(h);
+ if ( _volumesOnHexa.count(h)>0 ){
+ SMESHVolumes volumes = _volumesOnHexa[h];
+ for ( SMESHVolumes::iterator aVolume = volumes.begin(); aVolume != volumes.end(); ++aVolume ){
+ aGrEltIDs.push_back(*aVolume);
+ }
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF VOLUME: volume for hexa (id = "<<h->getId()<<") not found");
+ }
+ }
+ break;
+ case HEXA_NS::QuadCell:
+ {
+ HEXA_NS::Quad* q = reinterpret_cast<HEXA_NS::Quad*>(grHexElt);
+// HEXA_NS::Quad* q = dynamic_cast<HEXA_NS::Quad*>(grHexElt);
+// ASSERT(q);
+ if ( _facesOnQuad.count(q)>0 ){
+ SMESHFaces faces = _facesOnQuad[q];
+ for ( SMESHFaces::iterator aFace = faces.begin(); aFace != faces.end(); ++aFace ){
+ aGrEltIDs.push_back(*aFace);
+ }
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF FACE: face for quad (id = "<<q->getId()<<") not found");
+ }
+ }
+ break;
+ case HEXA_NS::EdgeCell:
+ {
+ HEXA_NS::Edge* e = reinterpret_cast<HEXA_NS::Edge*>(grHexElt);
+// HEXA_NS::Edge* e = dynamic_cast<HEXA_NS::Edge*>(grHexElt);
+// ASSERT(e);
+ if ( _edgesOnEdge.count(e)>0 ){
+ SMESHEdges edges = _edgesOnEdge[e];
+ for ( SMESHEdges::iterator anEdge = edges.begin(); anEdge != edges.end(); ++anEdge ){
+ aGrEltIDs.push_back(*anEdge);
+ }
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF Edge: edge for edge (id = "<<e->getId()<<") not found");
+ }
+ }
+ break;
+ case HEXA_NS::HexaNode:
+ {
+ HEXA_NS::Hexa* h = reinterpret_cast<HEXA_NS::Hexa*>(grHexElt);
+// HEXA_NS::Hexa* h = dynamic_cast<HEXA_NS::Hexa*>(grHexElt);
+// ASSERT(h);
+ if ( _volumesOnHexa.count(h)>0 ){
+ SMESHVolumes volumes = _volumesOnHexa[h];
+ for ( SMESHVolumes::iterator aVolume = volumes.begin(); aVolume != volumes.end(); ++aVolume ){
+ SMDS_ElemIteratorPtr aNodeIter = (*aVolume)->nodesIterator();
+ while( aNodeIter->more() ){
+ const SMDS_MeshNode* aNode =
+ dynamic_cast<const SMDS_MeshNode*>( aNodeIter->next() );
+ if ( aNode ){
+ aGrEltIDs.push_back(aNode);
+ }
+ }
+ }
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF HEXA NODES: nodes on hexa (id = "<<h->getId()<<") not found");
+ }
+ }
+ break;
+ case HEXA_NS::QuadNode:
+ {
+ HEXA_NS::Quad* q = reinterpret_cast<HEXA_NS::Quad*>(grHexElt);
+// HEXA_NS::Quad* q = dynamic_cast<HEXA_NS::Quad*>(grHexElt);
+// ASSERT(q);
+ if ( _quadNodes.count(q)>0 ){
+ ArrayOfSMESHNodes nodesOnQuad = _quadNodes[q];
+ for ( ArrayOfSMESHNodes::iterator nodes = nodesOnQuad.begin(); nodes != nodesOnQuad.end(); ++nodes){
+ for ( SMESHNodes::iterator aNode = nodes->begin(); aNode != nodes->end(); ++aNode){
+ aGrEltIDs.push_back(*aNode);
+ }
+ }
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF QUAD NODES: nodes on quad (id = "<<q->getId()<<") not found");
+ }
+ }
+ break;
+ case HEXA_NS::EdgeNode:
+ {
+ HEXA_NS::Edge* e = reinterpret_cast<HEXA_NS::Edge*>(grHexElt);
+// HEXA_NS::Edge* e = dynamic_cast<HEXA_NS::Edge*>(grHexElt);
+// ASSERT(e);
+ if ( _nodesOnEdge.count(e)>0 ){
+ SMESHNodes nodes = _nodesOnEdge[e];
+ for ( SMESHNodes::iterator aNode = nodes.begin(); aNode != nodes.end(); ++aNode){
+ aGrEltIDs.push_back(*aNode);
+ }
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF EDGE NODES: nodes on edge (id = "<<e->getId()<<") not found");
+ }
+ }
+ break;
+ case HEXA_NS::VertexNode:
+ {
+ HEXA_NS::Vertex* v = reinterpret_cast<HEXA_NS::Vertex*>(grHexElt);
+// HEXA_NS::Vertex* v = dynamic_cast<HEXA_NS::Vertex*>(grHexElt);
+// ASSERT(v);
+ if ( _node.count(v)>0 ){
+ aGrEltIDs.push_back(_node[v]);
+ } else {
+ if(MYDEBUG) MESSAGE("GROUP OF VERTEX NODES: nodes for vertex (id = "<<v->getId()<<") not found");
+ }
+ }
+ break;
+ default : ASSERT(false);
+ }
+ }
+
+ // B)Filling the group on SMESH
+ SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGr->GetGroupDS() );
+
+ for ( int i=0; i < aGrEltIDs.size(); i++ ) {
+ aGroupDS->SMDSGroup().Add( aGrEltIDs[i] );
+ };
+
+ if(MYDEBUG) MESSAGE("_fillGroup() : end >>>>>>>>");
+}
+
+
+
+
+
+// not used, for backup purpose only:
+void SMESH_HexaBlocks::_getCurve( const std::vector<HEXA_NS::Shape*>& shapesIn,
+ Handle_Geom_Curve& curveOut, double& curveFirstOut, double& curveLastOut )
+{
+// std::cout<<"------------------- _getCurve ------------ "<<std::endl;
+ GeomConvert_CompCurveToBSplineCurve* gen = NULL;
+
+ double curvesLenght = 0.;
+ double curvesFirst = shapesIn.front()->debut;
+ double curvesLast = shapesIn.back()->fin;
+
+ for ( std::vector <HEXA_NS::Shape*> ::const_iterator assoc = shapesIn.begin();
+ assoc != shapesIn.end();
+ ++assoc ){
+ string strBrep = (*assoc)->getBrep();
+ TopoDS_Shape shape = string2shape( strBrep );
+ TopoDS_Edge Edge = TopoDS::Edge(shape);
+ double f, l;
+ Handle(Geom_Curve) curve = BRep_Tool::Curve(Edge, f, l);
+ curvesLenght += l-f;
+ Handle(Geom_BoundedCurve) bCurve = Handle(Geom_BoundedCurve)::DownCast(curve);
+ if ( gen == NULL ){
+ gen = new GeomConvert_CompCurveToBSplineCurve(bCurve);
+ } else {
+ bool bb=gen->Add(bCurve, Precision::Confusion(), Standard_True, Standard_False, 1);
+ ASSERT(bb);
+ }
+ }
+ curveFirstOut = curvesFirst/curvesLenght;
+ curveLastOut = curvesLenght - (1.-curvesLast)/curvesLenght;
+ curveOut = gen->BSplineCurve();
+
+ std::cout<<"curvesFirst -> "<<curvesFirst<<std::endl;
+ std::cout<<"curvesLast -> "<<curvesLast<<std::endl;
+ std::cout<<"curvesLenght -> "<<curvesLenght<<std::endl;
+ std::cout<<"curveFirstOut -> "<<curveFirstOut<<std::endl;
+ std::cout<<"curveLastOut -> "<<curveLastOut<<std::endl;
+
+}
+
+
+
+
+
+// bool SMESH_HexaBlocks::_areSame(double a, double b)
+// {
+// return fabs(a - b) < HEXA_EPSILON;
+// }
+// // MESSAGE("Angular() :" << dir2.IsOpposite(dir1, Precision::Angular()));
+// // ASSERT( dir2.IsParallel(dir1, HEXA_QUAD_WAY) );
+// // bool test2 = norm2.IsOpposite(norm1, HEXA_QUAD_WAY2) == norm3.IsOpposite(norm1, HEXA_QUAD_WAY2);
+// // way = norm1.IsOpposite(norm3.Reversed(), HEXA_QUAD_WAY2);
+// gp_Pnt p( n->X(), n->Y(), n->Z() );
+// gp_Pnt ptOnPlane;
+// gp_Pnt ptOnSurface;
+// gp_Pnt ptOnPlaneOrSurface;
+// // gp_Vec norm2(p1, p);
+// TopoDS_Shape planeOrSurface;
+//
+//
+// gp_Pln pln(p1, dir1);
+// TopoDS_Shape shapePln = BRepBuilderAPI_MakeFace(pln).Face();
+// ptOnPlane = _intersect( p, a1, b1, shapePln );
+// ptOnPlaneOrSurface = ptOnPlane;
+//
+//
+// // if ( assoc != NULL ){
+// // MESSAGE("_computeQuadWay with assoc");
+// for( int i=0; i < h->countEdge(); ++i ){
+// HEXA_NS::Edge* e = h->getUsedEdge(i);
+// if ( e->definedBy(v1,v2) ){
+// const std::vector <HEXA_NS::Shape*> assocs = e->getAssociations();
+// if ( assocs.size() != 0 ){
+// HEXA_NS::Shape* assoc = assocs[0]; //CS_TODO
+// string theBrep = assoc->getBrep();
+// TopoDS_Shape theShape = string2shape( theBrep );
+// ptOnSurface = _intersect( p, a1, b1, theShape );
+// if ( !ptOnSurface.IsEqual(p, HEXA_EPSILON) ){
+// ptOnPlaneOrSurface = ptOnSurface;
+// }
+// }
+// }
+// }
+//
--- /dev/null
+// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File : SMESH_HexaBlocks.hxx
+// Author :
+// Module : SMESH
+//
+#ifndef _SMESH_HexaBlocks_HeaderFile
+#define _SMESH_HexaBlocks_HeaderFile
+
+#include <SALOMEconfig.h>
+
+#ifdef WNT
+# if defined HEXABLOCKS_EXPORTS || defined HexaBlocks_EXPORTS
+# define HEXABLOCKS_EXPORT __declspec( dllexport )
+# else
+# define HEXABLOCKS_EXPORT __declspec( dllimport )
+# endif
+#else
+# define HEXABLOCKS_EXPORT
+#endif
+
+#include "SMESH_Mesh.hxx"
+#include "SMESH_Group.hxx"
+#include "hexa_base.hxx" // from HexaBlocks
+
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#endif
+
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+#include <TopoDS_Face.hxx>
+#include "Handle_Geom_Curve.hxx"
+#include <BRepAdaptor_Curve.hxx>
+
+//=====================================================================
+// SMESH_HexaBlocks : class definition
+//=====================================================================
+class HEXABLOCKS_EXPORT SMESH_HexaBlocks
+{
+public:
+
+// typedef std::vector<double> Xx;
+ typedef std::vector<SMDS_MeshVolume*> SMESHVolumes;
+ typedef std::vector<SMDS_MeshNode*> SMESHNodes;
+ typedef std::vector<SMDS_MeshFace*> SMESHFaces;
+ typedef std::vector<SMDS_MeshEdge*> SMESHEdges;
+
+ typedef std::vector< SMESHNodes > ArrayOfSMESHNodes;
+
+ struct Coord{
+ double x;
+ double y;
+ double z;
+ };
+
+
+ SMESH_HexaBlocks(SMESH_Mesh& theMesh);
+ ~SMESH_HexaBlocks();
+
+ // --------------------------------------------------------------
+ // Vertex computing
+ // --------------------------------------------------------------
+ bool computeVertex( HEXA_NS::Vertex& vertex );
+ // Association solving
+ bool computeVertexByAssoc( HEXA_NS::Vertex& vertex );
+ // Automatic solving
+ bool computeVertexByModel( HEXA_NS::Vertex& vertex );
+
+
+ // --------------------------------------------------------------
+ // Edge computing
+ // --------------------------------------------------------------
+ bool computeEdge( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+ // Association solving
+ bool computeEdgeByAssoc( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+
+ // Automatic solving
+ bool computeEdgeByShortestWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+ bool computeEdgeByPlanWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+ bool computeEdgeByIsoWire( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+ bool computeEdgeBySegment( HEXA_NS::Edge& edge, HEXA_NS::Law& law);
+
+ // --------------------------------------------------------------
+ // Quad computing
+ // --------------------------------------------------------------
+ std::map<HEXA_NS::Quad*, bool> computeQuadWays( HEXA_NS::Document* doc );
+ bool computeQuad( HEXA_NS::Quad& quad, bool way );
+ // Association solving
+ bool computeQuadByAssoc( HEXA_NS::Quad& quad, bool way );
+ // Automatic solving
+ bool computeQuadByFindingGeom( HEXA_NS::Quad& quad, bool way );
+ bool computeQuadByLinearApproximation( HEXA_NS::Quad& quad, bool way );
+
+ // --------------------------------------------------------------
+ // Hexa computing
+ // --------------------------------------------------------------
+ bool computeHexa( HEXA_NS::Document* doc );
+
+ // --------------------------------------------------------------
+ // Document computing: Vertex, Edge, Quad and Hexa computing
+ // --------------------------------------------------------------
+ bool computeDoc( HEXA_NS::Document* doc );
+
+
+ // --------------------------------------------------------------
+ // Build groups
+ // --------------------------------------------------------------
+ void buildGroups(HEXA_NS::Document* doc);
+
+
+private:
+ // ******** METHOD FOR MESH COMPUTATION ********
+ // EDGE
+ double _Xx( double i, HEXA_NS::Law law, double nbNodes );
+
+ double _edgeLength(const TopoDS_Edge & E);
+
+ void _buildMyCurve(
+ const std::vector <HEXA_NS::Shape*>& associations, //IN
+ const gp_Pnt& myCurve_start, //IN
+ const gp_Pnt& myCurve_end, //IN
+ std::list< BRepAdaptor_Curve* >& myCurve, //INOUT
+ double& myCurve_length, //INOUT
+ std::map< BRepAdaptor_Curve*, double>& myCurve_lengths,//INOUT
+ std::map< BRepAdaptor_Curve*, bool>& myCurve_ways, //INOUT
+ std::map< BRepAdaptor_Curve*, double>& myCurve_starts, //INOUT
+ HEXA_NS::Edge& edge); // For diagnostic
+
+ gp_Pnt _getPtOnMyCurve(
+ const double& myCurve_u, //IN
+ std::map< BRepAdaptor_Curve*, bool>& myCurve_ways, //IN
+ std::map< BRepAdaptor_Curve*, double>& myCurve_lengths,//IN
+ std::map< BRepAdaptor_Curve*, double>& myCurve_starts, //IN
+ std::list< BRepAdaptor_Curve* >& myCurve, //INOUT
+ double& myCurve_start); //INOUT
+
+ // QUAD
+ void _nodeInterpolationUV( double u, double v,
+ SMDS_MeshNode* Pg, SMDS_MeshNode* Pd, SMDS_MeshNode* Ph, SMDS_MeshNode* Pb,
+ SMDS_MeshNode* S0, SMDS_MeshNode* S1, SMDS_MeshNode* S2, SMDS_MeshNode* S3,
+ double& xOut, double& yOut, double& zOut );
+
+ TopoDS_Shape _getShapeOrCompound( const std::vector<HEXA_NS::Shape*>& shapesIn );
+
+ gp_Pnt _intersect( const gp_Pnt& Pt,
+ const gp_Vec& u, const gp_Vec& v,
+ const TopoDS_Shape& s,
+ Standard_Real tol = 0.0001 );
+
+ bool _computeQuadInit(
+ HEXA_NS::Quad& quad,
+ ArrayOfSMESHNodes& nodesOnQuad,
+ std::vector<double>& xx, std::vector<double>& yy);
+
+ void _searchInitialQuadWay( HEXA_NS::Quad* quad, //IN
+ HEXA_NS::Vertex*& v0, //INOUT
+ HEXA_NS::Vertex*& v1 ); //INOUT
+
+
+ // ******** DATA FOR MESH COMPUTATION ********
+ // NODES
+ std::map<HEXA_NS::Vertex*, SMDS_MeshNode*> _node; //_vertexNode;
+ std::map<const SMDS_MeshNode*, HEXA_NS::Vertex*> _vertex; //_nodeVertex;
+
+ // EDGES
+ std::map<HEXA_NS::Edge*, SMESHNodes> _nodesOnEdge; //_edgeNodes;
+// std::map<HEXA_NS::Edge*, Xx> _edgeXx;
+ std::map<SMDS_MeshNode*, double> _nodeXx; //_edgeNodes;
+ std::map<HEXA_NS::Quad*, ArrayOfSMESHNodes> _quadNodes;
+
+ bool _computeVertexOK;
+ bool _computeEdgeOK;
+ bool _computeQuadOK;
+
+ SMESHDS_Mesh* _theMeshDS;
+ SMESH_Mesh* _theMesh;
+
+ // ******** METHOD FOR GROUPS COMPUTATION ********
+ SMESH_Group* _createGroup(HEXA_NS::Group& grHex);
+ void _fillGroup(HEXA_NS::Group* grHex);
+
+ // ******** DATA FOR GROUPS COMPUTATION ********
+ std::map<HEXA_NS::Hexa*, SMESHVolumes> _volumesOnHexa;
+ std::map<HEXA_NS::Quad*, SMESHFaces> _facesOnQuad;
+ std::map<HEXA_NS::Edge*, SMESHEdges> _edgesOnEdge;
+
+
+ // for DEBUG purpose only:
+ int _total;
+ int _found;
+ int _notFound;
+
+ // not used, for backup purpose only:
+ void _getCurve( const std::vector<HEXA_NS::Shape*>& shapesIn,
+ Handle_Geom_Curve& curveOut, double& curveFirstOut, double& curveLastOut );
+// bool computeEdgeByAssoc2( HEXA_NS::Edge& edge, HEXA_NS::Law& law); // alternative method
+};
+
+
+#endif
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# Module : HEXABLOCKPLUGIN
+# Date : 2010/11/08
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+# header files
+salomeinclude_HEADERS = \
+ HEXABLOCKPlugin_Defs.hxx \
+ HEXABLOCKPlugin_HEXABLOCK.hxx \
+ HEXABLOCKPlugin_HEXABLOCK_i.hxx \
+ HEXABLOCKPlugin_Hypothesis.hxx \
+ HEXABLOCKPlugin_Hypothesis_i.hxx \
+ HEXABLOCKPlugin_mesh.hxx \
+ HEXABLOCKPlugin_FromSkin_3D.hxx
+
+# Libraries targets
+lib_LTLIBRARIES = libHexaBlockEngine.la
+
+dist_libHexaBlockEngine_la_SOURCES = \
+ HEXABLOCKPlugin_HEXABLOCK.cxx \
+ HEXABLOCKPlugin_HEXABLOCK_i.cxx \
+ HEXABLOCKPlugin_i.cxx \
+ HEXABLOCKPlugin_Hypothesis.cxx \
+ HEXABLOCKPlugin_Hypothesis_i.cxx \
+ HEXABLOCKPlugin_mesh.cxx \
+ HEXABLOCKPlugin_FromSkin_3D.cxx
+
+libHexaBlockEngine_la_CPPFLAGS = \
+ $(KERNEL_CXXFLAGS) \
+ $(CAS_CPPFLAGS) \
+ $(VTK_INCLUDES) \
+ $(GEOM_CXXFLAGS) \
+ $(HEXABLOCK_CXXFLAGS) \
+ $(MED_CXXFLAGS) \
+ $(SMESH_CXXFLAGS) \
+ $(BOOST_CPPFLAGS) \
+ $(CORBA_CXXFLAGS) \
+ $(CORBA_INCLUDES) \
+ -I$(top_builddir)/idl
+
+libHexaBlockEngine_la_LDFLAGS = \
+ ../../idl/libSalomeIDLHEXABLOCKPLUGIN.la \
+ $(CAS_KERNEL) -lTKBRep -lTKG2d -lTKG3d -lTKTopAlgo -lTKGeomBase -lTKGeomAlgo \
+ $(HEXABLOCK_LDFLAGS) -lHEXABLOCKEngine \
+ $(MED_LDFLAGS) -lSalomeIDLMED \
+ $(SMESH_LDFLAGS) -lSMESHimpl -lSMESHEngine -lSMESHDS -lSMDS \
+ $(KERNEL_LDFLAGS) -lSalomeGenericObj -lSALOMELocalTrace -lSALOMEBasics
--- /dev/null
+# Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+# -* Makefile *-
+# Author : Lioka RAZAFINDRAZAKA (CEA)
+# Modified by : Alexander BORODIN (OCN) - autotools usage
+# Module : HEXABLOCKPLUGIN
+# Date : 2010/11/08
+#
+include $(top_srcdir)/adm_local/unix/make_common_starter.am
+
+SUBDIRS = HEXABLOCKPlugin
+
+if HEXABLOCKPLUGIN_ENABLE_GUI
+ SUBDIRS += GUI
+endif
+
+DIST_SUBDIRS = HEXABLOCKPlugin GUI
