propagate.png
redo.png
undo.png
+ setcolor.png
glue2.png
remove_webs.png
remove_extra_edges.png
# additional include directories
INCLUDE_DIRECTORIES(
${PTHREAD_INCLUDE_DIR}
- ${OpenCASCADE_INCLUDE_DIR}
+ ${CAS_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS}
${GUI_INCLUDE_DIRS}
${PROJECT_SOURCE_DIR}/src/GEOMUtils
# additional preprocessor / compiler flags
ADD_DEFINITIONS(
+ ${CAS_DEFINITIONS}
${OpenCASCADE_DEFINITIONS}
${QT_DEFINITIONS}
)
# libraries to link to
SET(_link_LIBRARIES
+ ${CAS_KERNEL}
+ ${CAS_TKernel}
GEOMUtils
)
IF(SALOME_BUILD_GUI)
SET(_other_HEADERS
CurveCreator.hxx
CurveCreator_Curve.hxx
+ CurveCreator_ShapeFilter.hxx
CurveCreator_Diff.hxx
CurveCreator_Displayer.hxx
CurveCreator_ICurve.hxx
CurveCreator_Curve.cxx
CurveCreator_Diff.cxx
CurveCreator_Displayer.cxx
+ CurveCreator_ShapeFilter.cxx
CurveCreator_Operation.cxx
CurveCreator_Section.cxx
CurveCreator_Utils.cxx
#include <AIS_Shape.hxx>
#include <AIS_InteractiveObject.hxx>
#include <Geom_CartesianPoint.hxx>
+#include <TopoDS_Iterator.hxx>
#include <gp_Pnt.hxx>
#include <gp_Lin.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
-
+#include <TopoDS_Shape.hxx>
+#include <AIS_ColoredShape.hxx>
#include <Prs3d_PointAspect.hxx>
#include <iostream>
#define DEBTRACE(msg) {std::cerr<<std::flush<<__FILE__<<" ["<<__LINE__<<"] : "<<msg<<std::endl<<std::flush;}
myOpLevel(0),
mySkipSorting(false),
myPointAspectColor (Quantity_NOC_ROYALBLUE4),
- myCurveColor (Quantity_NOC_RED),
+ //myCurveColor (Quantity_NOC_RED),
myEraseAll(true),
myLineWidth(1)
{
//! For internal use only! Undo/Redo are not used here.
int CurveCreator_Curve::addSectionInternal
(const std::string& theName, const CurveCreator::SectionType theType,
- const bool theIsClosed, const CurveCreator::Coordinates &thePoints)
+ const bool theIsClosed, const CurveCreator::Coordinates &thePoints,
+ const Quantity_Color& aColor)
{
CurveCreator_Section *aSection = new CurveCreator_Section;
aSection->myType = theType;
aSection->myIsClosed = theIsClosed;
aSection->myPoints = thePoints;
+ aSection->myColor = aColor;//getRandColor(); //TODO temp
mySections.push_back(aSection);
redisplayCurve(false);
return mySections.size()-1;
theName, aCoords, theType, theIsClosed);
}
- resISection = addSectionInternal(theName, theType, theIsClosed, aCoords);
+ Quantity_Color aRColor = CurveCreator_Utils::getRandColor();
+
+ resISection = addSectionInternal(theName, theType, theIsClosed, aCoords, aRColor);
finishOperation();
return resISection;
theName, thePoints, theType, theIsClosed);
}
- resISection = addSectionInternal(theName, theType, theIsClosed, thePoints);
+ resISection = addSectionInternal(theName, theType, theIsClosed, thePoints, Quantity_NOC_YELLOW);
finishOperation();
return resISection;
//! For internal use only! Undo/Redo are not used here.
bool CurveCreator_Curve::removeSectionInternal( const int theISection )
{
- if (theISection == -1) {
+ if (theISection == -1)
+ {
+ myRemColors.push_back(mySections.back()->myColor);
delete mySections.back();
mySections.pop_back();
} else {
CurveCreator::Sections::iterator anIterRm = mySections.begin() + theISection;
+ myRemColors.push_back((*anIterRm)->myColor);
+
delete *anIterRm;
mySections.erase(anIterRm);
}
return res;
}
+bool CurveCreator_Curve::setColorSection( int SectInd, Quantity_Color theNewColor )
+{
+ bool res = false;
+ // Set the difference.
+ startOperation();
+
+ int ColorParam[3] = { (int)( theNewColor.Red() * 255 ),
+ (int)( theNewColor.Green() * 255 ),
+ (int)( theNewColor.Blue() * 255 ) };
+
+ if (addEmptyDiff())
+ myListDiffs.back().init(this, CurveCreator_Operation::SetColorSection, SectInd, ColorParam);
+
+ setColorSectionInternal(SectInd, theNewColor);
+
+ finishOperation();
+ return res;
+}
+
+void CurveCreator_Curve::setColorSectionInternal( int SectInd, Quantity_Color theNewColor )
+{
+ CurveCreator_Section* aSec = (CurveCreator_Section*)(getSection(SectInd));
+ aSec->myColor = theNewColor;
+
+ redisplayCurve(false);
+}
+
+Quantity_Color CurveCreator_Curve::getColorSection( int SectInd ) const
+{
+ CurveCreator_Section* aSec = (CurveCreator_Section*)(getSection(SectInd));
+ return aSec->myColor;
+}
+
+Quantity_Color CurveCreator_Curve::getLastRemovedColor() const
+{
+ return myRemColors.empty() ? Quantity_NOC_BLACK : myRemColors.back();
+}
+
+void CurveCreator_Curve::popLastRemovedColor()
+{
+ myRemColors.pop_back();
+}
+
/**
* Get number of points in specified section or (the total number of points
* in Curve if theISection is equal to -1).
CurveCreator_Section* aSection = (CurveCreator_Section*)getSection( theISection );
return aSection ? aSection->GetDifferentPoints( (int)myDimension ) : Handle(TColgp_HArray1OfPnt)();
}
-
void CurveCreator_Curve::constructAISObject()
{
//DEBTRACE("constructAISObject");
TopoDS_Shape aShape;
- CurveCreator_Utils::constructShape( this, aShape );
- myAISShape = new AIS_Shape( aShape );
- myAISShape->SetColor( myCurveColor );
+ mySect2Shape.Clear();
+ CurveCreator_Utils::constructShape( this, aShape, &mySect2Shape );
+ myAISShape = new AIS_ColoredShape( aShape );
+ AIS_ColoredShape* AISColoredShape = dynamic_cast<AIS_ColoredShape*>(myAISShape);
+
+ std::map<int, TopoDS_Shape>::iterator it;
+
+ //for ( it = mySect2Shape.begin(); it != mySect2Shape.end(); it++ )
+ for (int i = 1; i <= mySect2Shape.Extent(); i++ )
+ {
+ CurveCreator_Section* aSect = (CurveCreator_Section*)getSection(mySect2Shape.FindKey(i));
+ Quantity_Color aColor = aSect->myColor;
+ const TopoDS_Shape& aShape = mySect2Shape.FindFromIndex(i); //should contain: one wire + vertices
+ TopoDS_Iterator it(aShape);
+ for (;it.More();it.Next())
+ {
+ if (it.Value().ShapeType() == TopAbs_WIRE)
+ AISColoredShape->SetCustomColor(it.Value(), aColor);
+ }
+ }
+
+ // myAISShape->SetColor( myCurveColor );
myAISShape->SetWidth( myLineWidth );
Handle(Prs3d_PointAspect) anAspect = myAISShape->Attributes()->PointAspect();
anAspect->SetScale( 3.0 );
#include <list>
#include <map>
+#include <NCollection_IndexedDataMap.hxx>
struct CurveCreator_Section;
class CurveCreator_Displayer;
class AIS_Shape;
class AIS_InteractiveObject;
class Quantity_Color;
+class TopoDS_Shape;
/**
* The CurveCreator_Curve object is represented as one or more sets of
public: // TODO: remove public
void getCoordinates( int theISection, int theIPoint, double& theX, double& theY, double& theZ ) const;
-protected: // TODO: remove public
+protected: //TODO
void redisplayCurve(bool preEraseAllObjects = true);
public:
virtual int addSectionInternal( const std::string &theName,
const CurveCreator::SectionType theType,
const bool theIsClosed,
- const CurveCreator::Coordinates &thePoints);
+ const CurveCreator::Coordinates &thePoints,
+ const Quantity_Color& aColor);
//! Add a new section.
virtual int addSection( const std::string &theName,
const CurveCreator::SectionType theType,
virtual bool setClosed( const int theISection,
const bool theIsClosed );
+ //! Sets color of section by index
+ virtual bool setColorSection( int SectInd, Quantity_Color theNewColor );
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual void setColorSectionInternal( int SectInd, Quantity_Color theNewColor );
+
+ virtual Quantity_Color getLastRemovedColor() const;
+
+ virtual void popLastRemovedColor();
+
+ //! Gets color of section by index
+ virtual Quantity_Color getColorSection( int SectInd ) const;
+
//! Returns specifyed section name
virtual std::string getSectionName( const int theISection ) const;
*/
virtual Handle(AIS_InteractiveObject) getAISObject( const bool theNeedToBuild = false) const;
+
+
protected:
/**
* Removes the points from the section. It sortes the points and remove them
protected:
bool mySkipSorting;
+ AIS_Shape* myAISShape; //!< AIS shape
+
public:
bool myIsLocked;
CurveCreator::Dimension myDimension; //!< curve dimension
CurveCreator_Displayer* myDisplayer; //!< curve displayer
Quantity_Color myPointAspectColor;
- Quantity_Color myCurveColor;
+ //Quantity_Color myCurveColor;
double myLineWidth;
+ NCollection_IndexedDataMap<int, TopoDS_Shape> mySect2Shape;
+ std::vector<int> myCurSectInd;
private:
ListDiff myListDiffs;
int myUndoDepth;
int myOpLevel;
- AIS_Shape* myAISShape; //!< AIS shape
bool myEraseAll;
+ std::vector<Quantity_Color> myRemColors;
};
#endif
#include "CurveCreator_Diff.hxx"
#include "CurveCreator_Curve.hxx"
+#include "CurveCreator_Section.hxx"
+#include "CurveCreator_Utils.hxx"
#include <list>
return isOK;
}
+bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
+ const CurveCreator_Operation::Type theType,
+ const int theIntParam1,
+ const int theIntParam2[3])
+{
+ bool isOK = false;
+
+ if (theCurve != NULL)
+ {
+ clear();
+ myPRedo = new CurveCreator_Operation;
+
+ if (myPRedo->init(theType, theIntParam1, theIntParam2))
+ {
+ Quantity_Color aColor = theCurve->getColorSection(theIntParam1);
+
+ setNbUndos(1);
+ QColor aQColor = CurveCreator_Utils::colorConv(aColor);
+ int colorArr[3] = {aQColor.red(),aQColor.green(), aQColor.blue()};
+
+ isOK = myPUndo[0].init(theType, theIntParam1, colorArr);
+ }
+
+ if (!isOK)
+ clear();
+ }
+
+ return isOK;
+}
+
//=======================================================================
// function: init
// purpose:
bool init(const CurveCreator_Curve *theCurve,
const CurveCreator_ICurve::SectionToPointCoordsList &theOldParamList);
+
+ /**
+ * This method initializes the difference with an operation with one
+ * integer and one array of integer[3] parameters.
+ * It is applicable to the following operations:
+ * <UL>
+ * <LI>ColorSection</LI>
+ * </UL>
+ */
+ bool init(const CurveCreator_Curve *theCurve,
+ const CurveCreator_Operation::Type theType,
+ const int theIntParam1,
+ const int theIntParam2[3]);
+
/**
* This method applies undo operation to theCurve.
*/
void eraseAll( bool isUpdate );
void erase( const Handle(AIS_InteractiveObject)& theObject, bool isUpdate );
void Update();
+
+ Handle(AIS_InteractiveContext) getContext()
+ {
+ return myContext;
+ }
+
//void highlight( const AISObjectsList& theObjects, bool isHL );
protected:
#include "CurveCreator_Operation.hxx"
#include "CurveCreator_Curve.hxx"
#include "CurveCreator.hxx"
+#include "CurveCreator_Section.hxx"
+#include "CurveCreator_Utils.hxx"
+#include <QColor>
#include <string>
#include <stdlib.h>
return isOK;
}
+bool CurveCreator_Operation::init(const CurveCreator_Operation::Type theType,
+ const int theIntParam1,
+ const int theIntParam2[3])
+{
+ bool isOK = false;
+
+ if (theType == CurveCreator_Operation::SetColorSection)
+ {
+ int *pData = (int *)allocate(4*sizeof(int));
+
+ pData[0] = theIntParam1;
+ pData[1] = theIntParam2[0];
+ pData[2] = theIntParam2[1];
+ pData[3] = theIntParam2[2];
+ myType = theType;
+ isOK = true;
+ }
+
+ return isOK;
+}
+
+
//=======================================================================
// function: Constructor
// purpose:
char* aPtr = ((char*)&pInt[2]);
aPtr += (aName.length()) + 1;
getCoords((int*)aPtr, aCoords);
- theCurve->addSectionInternal(aName, aType, (pInt[1] != 0), aCoords);
+ Quantity_Color aLastColor = theCurve->getLastRemovedColor();
+ theCurve->popLastRemovedColor();
+ theCurve->addSectionInternal(aName, aType, (pInt[1] != 0), aCoords, aLastColor);
}
break;
case CurveCreator_Operation::RemoveSection:
theCurve->setSectionNameInternal(pInt[0], aName);
}
break;
+ case CurveCreator_Operation::SetColorSection:
+ {
+ Quantity_Color aColor = CurveCreator_Utils::colorConv(QColor(pInt[1], pInt[2], pInt[3]));
+ theCurve->setColorSectionInternal(pInt[0], aColor);
+ //theCurve->redisplayCurve(false);
+ }
+ break;
default:
break;
}
Join, //!< Method CurveCreator_Curve::join
AddSection, //!< Method CurveCreator_Curve::addSection
RemoveSection, //!< Method CurveCreator_Curve::removeSection
- RenameSection //!< Method CurveCreator_Curve::renameSection
+ RenameSection, //!< Method CurveCreator_Curve::renameSection
+ SetColorSection //!< Method CurveCreator_Curve::setColorSection
+
};
/**
bool init(const Type theType, const int theIntParam1,
const int theIntParam2);
+ /**
+ * This method initializes the object with an operation with 4 integer
+ * parameter (1 as first param + 3 as interger array)
+ */
+ bool init(const Type theType, const int theIntParam1,
+ const int theIntParam2[3]);
+
+
/**
* This method initializes the object with an operation with two integer
* parameters. It is applicable to the following operations:
public CurveCreator_ISection
{
//! Constructor. Initializes object with default values.
- CurveCreator_Section() : myName("Section"),myType(CurveCreator::Polyline), myIsClosed(false)
+ CurveCreator_Section() : myName("Section"),myType(CurveCreator::Polyline),
+ myIsClosed(false), myColor (Quantity_NOC_RED)
{ }
std::string myName; //!< section name
CurveCreator::Coordinates myPoints; //!< points coordinates
CurveCreator::SectionType myType; //!< type of the section
bool myIsClosed; //!< closed or not
+ Quantity_Color myColor; //!< color of section
//! A virtual method.
Handle(TColgp_HArray1OfPnt) GetDifferentPoints( int theDimension ) const;
--- /dev/null
+// Copyright (C) 2013-2019 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File: CurveCreator_ShapeFilter.cxx
+// Author: Ilya Shchekin
+
+
+#include "CurveCreator_ShapeFilter.hxx"
+
+#include <SelectMgr_EntityOwner.hxx>
+#include <StdSelect_BRepOwner.hxx>
+#include <TopoDS_Vertex.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(CurveCreator_ShapeFilter,SelectMgr_Filter)
+
+CurveCreator_ShapeFilter::CurveCreator_ShapeFilter()
+: SelectMgr_Filter()
+{
+}
+
+CurveCreator_ShapeFilter::~CurveCreator_ShapeFilter()
+{
+}
+
+Standard_Boolean CurveCreator_ShapeFilter::ActsOn(const TopAbs_ShapeEnum aType) const
+{
+ return (aType == TopAbs_VERTEX);
+}
+
+Standard_Boolean CurveCreator_ShapeFilter::IsOk(const Handle(SelectMgr_EntityOwner)& EO) const
+{
+ Handle(StdSelect_BRepOwner) aBO = Handle(StdSelect_BRepOwner)::DownCast(EO);
+ if (aBO.IsNull())
+ return Standard_False;
+
+ const TopoDS_Shape& aShape = aBO->Shape();
+
+ if(aShape.ShapeType()!= TopAbs_VERTEX)
+ return Standard_False;
+
+ return myShapes.Contains(aShape);
+}
+
+void CurveCreator_ShapeFilter::AddShape(const TopoDS_Shape& aShape)
+{
+ myShapes.Add(aShape);
+}
+
+void CurveCreator_ShapeFilter::RemoveShape(const TopoDS_Shape& aShape)
+{
+ myShapes.Remove(aShape);
+}
+
+void CurveCreator_ShapeFilter::ClearShapes()
+{
+ myShapes.Clear();
+}
+
--- /dev/null
+// Copyright (C) 2013-2019 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File: CurveCreator_ShapeFilter.hxx
+// Author: Ilya Shchekin
+
+
+#ifndef _CurveCreator_ShapeFilter_HeaderFile
+#define _CurveCreator_ShapeFilter_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <Basics_OCCTVersion.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <SelectMgr_Filter.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <TopTools_MapOfShape.hxx>
+
+class SelectMgr_EntityOwner;
+class TopoDS_Shape;
+
+
+class CurveCreator_ShapeFilter : public SelectMgr_Filter
+{
+
+public:
+
+
+ Standard_EXPORT CurveCreator_ShapeFilter();
+
+ Standard_EXPORT ~CurveCreator_ShapeFilter();
+
+ Standard_EXPORT virtual Standard_Boolean ActsOn (const TopAbs_ShapeEnum aType) const Standard_OVERRIDE;
+
+ Standard_EXPORT virtual Standard_Boolean IsOk (const Handle(SelectMgr_EntityOwner)& EO) const Standard_OVERRIDE;
+
+ Standard_EXPORT void AddShape (const TopoDS_Shape& aShape);
+
+ Standard_EXPORT void RemoveShape (const TopoDS_Shape& aShape);
+
+ Standard_EXPORT void ClearShapes ();
+
+
+private:
+
+ TopTools_MapOfShape myShapes;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(CurveCreator_ShapeFilter,SelectMgr_Filter)
+
+};
+
+DEFINE_STANDARD_HANDLE(CurveCreator_ShapeFilter, SelectMgr_Filter)
+
+#endif
+
\ No newline at end of file
#include "CurveCreator_TreeView.h"
#include "CurveCreator_ICurve.hxx"
+#include "CurveCreator_Curve.hxx"
+#include "CurveCreator_Utils.hxx"
#include <SUIT_Session.h>
#include <SUIT_ResourceMgr.h>
#define ID_SECTION -1
-CurveCreator_TreeViewModel::CurveCreator_TreeViewModel( CurveCreator_ICurve* theCurve, QObject* parent ) :
- QAbstractItemModel(parent), myCurve(theCurve)
+CurveCreator_TreeViewModel::CurveCreator_TreeViewModel( CurveCreator_ICurve* theCurve, QObject* parent, bool toDrawColorIcon ) :
+ QAbstractItemModel(parent), myCurve(theCurve), myDrawColorIcon(toDrawColorIcon)
{
SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
QPixmap aSplineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
int CurveCreator_TreeViewModel::columnCount(const QModelIndex & parent ) const
{
- if( parent.internalId() == ID_SECTION )
- return 2;
+ if( myDrawColorIcon )
+ return 3;
else
return 2;
}
}
}
}
+ else if (myDrawColorIcon && aColumn == 2)
+ {
+ Quantity_Color color = ((CurveCreator_Curve*)myCurve)->getColorSection(aRow);
+ QPixmap pixmap(16,16);
+ pixmap.fill( CurveCreator_Utils::colorConv(color));
+ return pixmap;
+ }
}
}
/* else{
}
/*****************************************************************************************/
-CurveCreator_TreeView::CurveCreator_TreeView( CurveCreator_ICurve* theCurve, QWidget *parent) :
+CurveCreator_TreeView::CurveCreator_TreeView( CurveCreator_ICurve* theCurve, QWidget *parent, bool toDrawColorIcon) :
QTreeView(parent)
{
header()->hide();
header()->setSectionResizeMode(QHeaderView::ResizeToContents);
setUniformRowHeights(true);
setContextMenuPolicy( Qt::CustomContextMenu );
- CurveCreator_TreeViewModel* aModel = new CurveCreator_TreeViewModel(theCurve, this);
+ CurveCreator_TreeViewModel* aModel = new CurveCreator_TreeViewModel(theCurve, this, toDrawColorIcon);
setModel(aModel);
setSelectionBehavior(SelectRows);
setSelectionMode(SingleSelection);
class CurveCreator_TreeViewModel : public QAbstractItemModel
{
public:
- CurveCreator_TreeViewModel( CurveCreator_ICurve* theCurve, QObject* parent );
+ CurveCreator_TreeViewModel( CurveCreator_ICurve* theCurve, QObject* parent, bool toDrawColorIcon );
virtual int columnCount(const QModelIndex & parent = QModelIndex()) const;
virtual int rowCount(const QModelIndex & parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
enum IconType{ ICON_POLYLINE, ICON_SPLINE, ICON_CLOSED_SPLINE, ICON_CLOSED_POLYLINE, ICON_POINT };
private:
CurveCreator_ICurve* myCurve;
+ bool myDrawColorIcon;
QMap<IconType, QPixmap> myCachedIcons;
};
public:
enum SelectionType{ ST_NOSEL, ST_POINTS, ST_POINTS_ONE_SECTION, ST_SECTIONS, ST_MIXED };
public:
- explicit CurveCreator_TreeView( CurveCreator_ICurve* theCurve, QWidget *parent = 0);
+ explicit CurveCreator_TreeView( CurveCreator_ICurve* theCurve, QWidget *parent = 0, bool toDrawColorIcon = true);
SelectionType getSelectionType() const;
QList<int> getSelectedSections() const;
// purpose :
//=======================================================================
void CurveCreator_Utils::constructShape(
- const CurveCreator_ICurve* theCurve, TopoDS_Shape& theShape)
+ const CurveCreator_ICurve* theCurve, TopoDS_Shape& theShape,
+ NCollection_IndexedDataMap<int, TopoDS_Shape>* theSect2Shape )
{
BRep_Builder aBuilder;
TopoDS_Compound aShape;
aBuilder.MakeCompound(aShape);
+
const int aSectionCount = theCurve->getNbSections();
for (int aSectionI = 0; aSectionI < aSectionCount; ++aSectionI)
{
const int aPointCount = aPoints->Length();
const bool isClosed = theCurve->isClosed(aSectionI);
+ TopoDS_Compound ShapeWireWithV;
+ if (theSect2Shape)
+ aBuilder.MakeCompound(ShapeWireWithV);
+
// Add the vertices to the shape.
for (Standard_Integer aPN = 1; aPN <= aPointCount; ++aPN)
{
- aBuilder.Add(aShape, BRepBuilderAPI_MakeVertex(aPoints->Value(aPN)));
+ TopoDS_Vertex V;
+ aBuilder.MakeVertex(V,aPoints->Value(aPN),Precision::Confusion());
+ aBuilder.Add(aShape, V);
+ if (theSect2Shape)
+ aBuilder.Add(ShapeWireWithV, V);
}
// Add the wire to the shape.
if (!aWire.IsNull())
{
aBuilder.Add(aShape, aWire);
+ if (theSect2Shape)
+ {
+ aBuilder.Add(ShapeWireWithV, aWire);
+ (*theSect2Shape).Add(aSectionI, ShapeWireWithV);
+ }
}
}
theShape = aShape;
Handle(TColgp_HArray1OfPnt) myPoints;
};
+Quantity_Color CurveCreator_Utils::getRandColor()
+{
+ float aHue = ( rand()%1000 ) * 0.001f;
+
+ QColor aColor;
+ aColor.setHsl( (int)(aHue*255.), 200, 128 );
+ int r = aColor.red();
+ int g = aColor.green();
+ int b = aColor.blue();
+
+ double r1 = r / 255.0;
+ double g1 = g / 255.0;
+ double b1 = b / 255.0;
+ return Quantity_Color( r1, g1, b1, Quantity_TOC_RGB );
+}
+
+Quantity_Color CurveCreator_Utils::colorConv(QColor color)
+{
+ return Quantity_Color( color.red() / 255.,
+ color.green() / 255., color.blue() / 255., Quantity_TOC_RGB );
+}
+
+QColor CurveCreator_Utils::colorConv(Quantity_Color color)
+{
+ return QColor( (int)( color.Red() * 255 ), (int)( color.Green() * 255 ), (int)( color.Blue() * 255 ) );
+}
+
//=======================================================================
// function : constructCurve
// purpose :
CurveCreator::Spline : CurveCreator::Polyline;
theCurve->addSectionInternal(aSecName, aSecType,
- aSecIt->myIsClosed, aCoords);
+ aSecIt->myIsClosed, aCoords, Quantity_NOC_RED);
}
// Set the local coordinate system.
#include <TopoDS_Wire.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <Geom_BSplineCurve.hxx>
+#include <QColor>
#include <list>
#include <vector> // TODO: remove
+#include <NCollection_IndexedDataMap.hxx>
class CurveCreator_Curve;
Handle(V3d_View) theView,
int& x, int& y );
+ /**
+ * Generates a random color
+ */
+ CURVECREATOR_EXPORT static Quantity_Color getRandColor();
+
+ /**
+ * Convert QColor to Quantity_Color
+ */
+ CURVECREATOR_EXPORT static Quantity_Color colorConv(QColor color);
+
+ /**
+ * Convert Quantity_Color to QColor
+ */
+ CURVECREATOR_EXPORT static QColor colorConv(Quantity_Color color);
+
/*!
* \brief Returns the point clicked in 3D view.
*
* Generates shape on the curve
* \param theCurve a curve object, that contains data
* \param theShape a generated shape
+ * \param Sect2Shape optional out map: section to constructed shape (wire+vertices)
*/
CURVECREATOR_EXPORT static void constructShape( const CurveCreator_ICurve* theCurve,
- TopoDS_Shape& theShape );
+ TopoDS_Shape& theShape,
+ NCollection_IndexedDataMap<int, TopoDS_Shape>* Sect2Shape = NULL);
/**
* Generates a curve from a shape.
#include "CurveCreator.hxx"
#include <gp_Pnt.hxx>
+#include <TopoDS_Shape.hxx>
const double LOCAL_SELECTION_TOLERANCE = 0.0001;
#include "CurveCreator_UtilsICurve.hxx"
#include "CurveCreator_TableView.h"
+#include "CurveCreator_Curve.hxx"
+#include "CurveCreator_Section.hxx"
+#include <QColorDialog>
+
#include <SUIT_Session.h>
#include <SUIT_Desktop.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_ViewManager.h>
+#include <TopExp_Explorer.hxx>
+#include "CurveCreator_ShapeFilter.hxx"
+
#include <OCCViewer_ViewManager.h>
#include <OCCViewer_ViewPort3d.h>
#include <OCCViewer_Utilities.h>
QGroupBox* aSectionGroup = new QGroupBox(tr("SECTION_GROUP_TITLE"),this);
- mySectionView = new CurveCreator_TreeView(myCurve, aSectionGroup);
+
+ bool toDrawSectColor = !(theActionFlags & DisableSetColor);
+
+ mySectionView = new CurveCreator_TreeView(myCurve, aSectionGroup, toDrawSectColor);
mySectionView->setSelectionMode( QTreeView::ExtendedSelection );
connect( mySectionView, SIGNAL(selectionChanged()), this, SLOT( onSelectionChanged() ) );
connect( mySectionView, SIGNAL(sectionEntered(int)), this, SLOT(onEditSection(int)) );
QPixmap aBringTogetherPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_BRING_TOGETHER")));
QPixmap aStepUpPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_UP")));
QPixmap aStepDownPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_DOWN")));
+ QPixmap aSetColorPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SETCOLOR")));
QAction* anAct = createAction( UNDO_ID, tr("UNDO"), anUndoPixmap, tr("UNDO_TLT"),
QKeySequence(Qt::ControlModifier|Qt::Key_Z) );
QKeySequence(Qt::ControlModifier|Qt::Key_Delete ) );
connect(anAct, SIGNAL(triggered()), this, SLOT(onRemove()) );
aTB->addAction(anAct);
+
+ anAct = createAction( SETCOLOR_ID, tr("SETCOLOR"), aSetColorPixmap, tr("SETCOLOR_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_C ) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onSetColor()) );
+
+ if ( !(theActionFlags & DisableSetColor) )
+ aTB->addAction(anAct);
anAct = createAction( JOIN_ID, tr("JOIN"), aJoinPixmap, tr("JOIN_TLT"),
QKeySequence(Qt::ControlModifier|Qt::Key_Plus ) );
updateActionsStates();
updateUndoRedo();
emit selectionChanged();
+ QList<int> selectedSections = mySectionView->getSelectedSections();
+ CurveCreator_Curve* Curve = ((CurveCreator_Curve*)myCurve);
+ Curve->myCurSectInd.clear();
+ foreach (int sectInd, selectedSections)
+ Curve->myCurSectInd.push_back(sectInd);
}
void CurveCreator_Widget::updateActionsStates()
if ( removeEnabled() )
anEnabledAct << REMOVE_ID;
QList<int> aSelSections = mySectionView->getSelectedSections();
+ if (aSelSections.size() == 1)
+ anEnabledAct << SETCOLOR_ID;
CurveCreator_TreeView::SelectionType aSelType = mySectionView->getSelectionType();
switch( aSelType ){
case CurveCreator_TreeView::ST_NOSEL:{
}
}
+void CurveCreator_Widget::onSetColor()
+{
+ if( !myCurve )
+ return;
+
+ QList<int> aSections = mySectionView->getSelectedSections();
+ if (aSections.size() != 1)
+ return;
+
+ int aSectNum = aSections[0];
+ Quantity_Color aColor = ((CurveCreator_Curve*)myCurve)->getColorSection( aSectNum );;
+
+ QColor aQColor = CurveCreator_Utils::colorConv(aColor);
+ QColor aNewQColor = QColorDialog::getColor( aQColor, this );
+ if( !aNewQColor.isValid() )
+ return;
+
+ Quantity_Color aNewColor = CurveCreator_Utils::colorConv(aNewQColor);
+
+ ((CurveCreator_Curve*)myCurve)->setColorSection( aSectNum, aNewColor);
+
+ updateUndoRedo();
+}
+
+
void CurveCreator_Widget::onClearAll()
{
if( !myCurve )
Handle(V3d_View) aView3d = aView->getViewPort()->getView();
if ( !aView3d.IsNull() )
{
+ CurveCreator_Curve* Curve = ((CurveCreator_Curve*)myCurve);
+ //if (!Curve->myCurSectInd.empty())
+ //{
+ aCtx->RemoveFilters();
+ Handle(CurveCreator_ShapeFilter) filter = new CurveCreator_ShapeFilter();
+ for (int i=0; i<Curve->myCurSectInd.size(); i++)
+ {
+ int sectInd = Curve->myCurSectInd[i];
+ const TopoDS_Shape& W = Curve->mySect2Shape(sectInd+1);
+ TopExp_Explorer exp(W, TopAbs_VERTEX);
+ for (;exp.More();exp.Next())
+ filter->AddShape(exp.Current());
+ }
+ aCtx->AddFilter(filter);
+ if (aCtx->HasOpenedContext())
+ {
+ Handle(AIS_LocalContext) aLctx = aCtx->LocalContext();
+ aLctx->Filter()->Clear();
+ aLctx->AddFilter(filter);
+ }
+ //}
+
// Initialize the single selection if start and end points are equal,
// otherwise a rectangular selection.
if ( myStartPoint == myEndPoint )
NoFlags = 0x00000000,
DisableDetectionMode = 0x00000001,
DisableNewSection = 0x00000002,
- DisableClosedSection = 0x00000004
+ DisableClosedSection = 0x00000004,
+ DisableSetColor = 0x00000008
};
enum ActionMode {
void onJoin();
void onBringTogether();
void onRemove();
+ void onSetColor();
void onClearAll();
void onJoinAll();
void onSetSpline();
SEPARATOR_ID,
MODIFICATION_MODE_ID,
DETECTION_MODE_ID,
- BRING_TOGETHER_ID
+ BRING_TOGETHER_ID,
+ SETCOLOR_ID
};
public:
<source>ICON_CC_UNDO</source>
<translation>undo.png</translation>
</message>
+ <message>
+ <source>ICON_CC_SETCOLOR</source>
+ <translation>setcolor.png</translation>
+ </message>
<message>
<source>ICON_FOLDER</source>
<translation>folder.png</translation>
<source>SET_SECTIONS_SPLINE_TLT</source>
<translation>Set selected section type to spline</translation>
</message>
+ <message>
+ <source>SETCOLOR</source>
+ <translation>Set color</translation>
+ </message>
+ <message>
+ <source>SETCOLOR_TLT</source>
+ <translation>Set color</translation>
+ </message>
<message>
<source>REMOVE</source>
<translation>Remove</translation>
GEOM::GEOM_Object_var aSubO;
switch (theFindMethod) {
case GEOM::FSM_GetInPlace:
- {
+ {
// Use GetInPlace
aSubO = aShapesOp->GetInPlace(theObject, anArgO);
}
