#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Session.h>
+#include <ModelAPI_Tools.h>
+#include <ModelAPI_ResultGroup.h>
#include <Events_Loop.h>
#include <Config_Translator.h>
+#include <Config_PropManager.h>
void ModelAPI_Feature::setError(const std::string& theError,
bool isSend,
// in any case result becomes enabled
if (!isDisabled()) // disabled feature may be executed when it is added as not enabled (#2078)
theResult->setDisabled(theResult, false);
+
+ Config_Prop* aProp = Config_PropManager::findProp("Visualization", "result_group_Auto_color");
+
+ if (aProp) {
+ bool anIsAutoColor = Config_PropManager::boolean("Visualization", "result_group_Auto_color");
+
+ if (anIsAutoColor && theResult->groupName() == ModelAPI_ResultGroup::group()) {
+ std::vector<int> aColor;
+ ModelAPI_Tools::findRandomColor(aColor);
+ ModelAPI_Tools::setColor(theResult, aColor);
+ }
+ }
}
void ModelAPI_Feature::setResult(const std::shared_ptr<ModelAPI_Result>& theResult,
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-#include "ModelAPI_Tools.h"
-#include <ModelAPI_Session.h>
+
+#include <ModelAPI_AttributeBoolean.h>
+#include <ModelAPI_AttributeDocRef.h>
+#include <ModelAPI_AttributeDouble.h>
+#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Document.h>
+#include <ModelAPI_Events.h>
#include <ModelAPI_Object.h>
-#include <ModelAPI_AttributeDouble.h>
-#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_ResultBody.h>
+#include <ModelAPI_ResultConstruction.h>
+#include <ModelAPI_ResultGroup.h>
#include <ModelAPI_ResultParameter.h>
#include <ModelAPI_ResultPart.h>
-#include <ModelAPI_ResultGroup.h>
-#include <ModelAPI_AttributeDocRef.h>
+#include <ModelAPI_Session.h>
+#include "ModelAPI_Tools.h"
#include <ModelAPI_Validator.h>
-#include <ModelAPI_AttributeIntArray.h>
-#include <ModelAPI_ResultConstruction.h>
-#include <ModelAPI_AttributeBoolean.h>
-#include <list>
-#include <map>
-#include <iostream>
-#include <sstream>
+#include <Config_Translator.h>
#include <Events_Loop.h>
#include <Locale_Convert.h>
-#include <ModelAPI_Events.h>
-#include <Config_Translator.h>
#include <GeomAPI_ShapeHierarchy.h>
#include <GeomAPI_ShapeIterator.h>
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <map>
+#include <sstream>
+
#define RECURSE_TOP_LEVEL 50
//#define DEBUG_REMOVE_FEATURES
return aResList;
}
+void setValues(std::vector<int>& theRGB, const int theRed, const int theGreen, const int theBlue)
+{
+ theRGB.push_back(theRed);
+ theRGB.push_back(theGreen);
+ theRGB.push_back(theBlue);
+}
+
+std::vector<int> HSVtoRGB(int theH, int theS, int theV)
+{
+ std::vector<int> aRGB;
+ if (theH < 0 || theH > 360 ||
+ theS < 0 || theS > 100 ||
+ theV < 0 || theV > 100)
+ return aRGB;
+
+ int aHi = (int)theH/60;
+ double aV = theV;
+ double aVmin = (100 - theS)*theV/100;
+ double anA = (theV - aVmin)* (theH % 60) / 60;
+ double aVinc = aVmin + anA;
+ double aVdec = theV - anA;
+ double aPercentToValue = 255./100;
+ int aV_int = (int)(aV*aPercentToValue);
+ int aVinc_int = (int)(aVinc*aPercentToValue);
+ int aVmin_int = (int)(aVmin*aPercentToValue);
+ int aVdec_int = (int)(aVdec*aPercentToValue);
+
+ switch(aHi) {
+ case 0: setValues(aRGB, aV_int, aVinc_int, aVmin_int); break;
+ case 1: setValues(aRGB, aVdec_int, aV_int, aVmin_int); break;
+ case 2: setValues(aRGB, aVmin_int, aV_int, aVinc_int); break;
+ case 3: setValues(aRGB, aVmin_int, aVdec_int, aV_int); break;
+ case 4: setValues(aRGB, aVinc_int, aVmin_int, aV_int); break;
+ case 5: setValues(aRGB, aV_int, aVmin_int, aVdec_int); break;
+ default: break;
+ }
+ return aRGB;
+}
+
+std::array<std::vector<int>, 10> myColorTab = {
+ std::vector<int> {255, 0, 0},
+ std::vector<int> {0, 255, 0},
+ std::vector<int> {0, 0, 255},
+ std::vector<int> {255, 255, 0},
+ std::vector<int> {0, 255, 255},
+ std::vector<int> {255, 0, 255},
+ std::vector<int> {255, 94, 0},
+ std::vector<int> {132, 255, 0},
+ std::vector<int> {132, 0, 255},
+ std::vector<int> {0, 0, 0},
+};
+
+void findRandomColor(std::vector<int>& theValues)
+{
+ static int i = 0;
+ static std::vector<std::vector<int>> usedGeneratedColor;
+
+ theValues.clear();
+ if (i < myColorTab.size()) {
+ theValues = myColorTab[i++];
+ } else {
+ int timeout = 0;
+ std::vector<int> aHSVColor;
+ std::vector<int> aRGBColor;
+
+ do {
+ aHSVColor = {rand() % 360 , rand()%(100 - 75 + 1) + 60, rand()%(100 - 60 + 1) + 75};
+ aRGBColor = HSVtoRGB(aHSVColor[0], aHSVColor[1], aHSVColor[2]);
+ timeout++;
+ } while (
+ timeout < 20 &&
+ std::find(usedGeneratedColor.begin(), usedGeneratedColor.end(), aHSVColor)
+ != usedGeneratedColor.end() &&
+ std::find(myColorTab.begin(), myColorTab.end(), aRGBColor) != myColorTab.end());
+ usedGeneratedColor.push_back(aHSVColor);
+ theValues = aRGBColor;
+ }
+}
+
// LCOV_EXCL_STOP
} // namespace ModelAPI_Tools
MODELAPI_EXPORT std::list<std::shared_ptr<ModelAPI_Feature> > referencedFeatures(
std::shared_ptr<ModelAPI_Result> theTarget, const std::string& theFeatureKind,
const bool theSortResults);
+
+
+/*! Returns a container with the current color value.
+* These are tree int values for RGB definition.
+* It returns the next random color.
+* \param theValues vector of values
+*/
+MODELAPI_EXPORT void findRandomColor(std::vector<int>& theValues);
+
}
#endif
Config_PropManager::registerProp("Visualization", "result_group_color", "Group color",
Config_Prop::Color, ModelAPI_ResultGroup::DEFAULT_COLOR());
- Config_PropManager::registerProp("Visualization",
- ModelAPI_ResultConstruction::RESULT_COLOR_NAME(),
- "Construction color", Config_Prop::Color, ModelAPI_ResultConstruction::DEFAULT_COLOR());
+ Config_PropManager::registerProp("Visualization", "result_group_Auto_color", "Auto color",
+ Config_Prop::Boolean, "false");
+
+ Config_PropManager::registerProp("Visualization", "result_construction_color",
+ "Construction color",
+ Config_Prop::Color,
+ ModelAPI_ResultConstruction::DEFAULT_COLOR());
Config_PropManager::registerProp("Visualization", "result_part_color", "Part color",
Config_Prop::Color, ModelAPI_ResultPart::DEFAULT_COLOR());
CompositeFeaturePtr aSketch = mySketchMgr->activeSketch();
if (aSketch.get()) {
ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- if (PartSet_SketcherMgr::isSketchOperation(anOperation) &&
+ if (PartSet_SketcherMgr::isSketchOperation(anOperation)&&
mySketchMgr->previewSketchPlane()->isDisplayed())
mySketchMgr->previewSketchPlane()->createSketchPlane(aSketch, myWorkshop);
}
return aValues;
}
-// contains global cash for integer index of the color -> RGB of this color
-static std::map<int, std::vector<int> > myColorMap;
-
-void appendValues(std::vector<int>& theRGB, const int theRed, const int theGreen, const int theBlue)
-{
- theRGB.push_back(theRed);
- theRGB.push_back(theGreen);
- theRGB.push_back(theBlue);
-}
-
-bool containsValues(std::map<int, std::vector<int> >& theColorMap, std::vector<int>& theValues)
-{
- std::map<int, std::vector<int> >::const_iterator anIt = theColorMap.begin(),
- aLast = theColorMap.end();
- bool isFound = false;
- for (; anIt != aLast && !isFound; anIt++) {
- std::vector<int> aValues = anIt->second;
- isFound = aValues[0] == theValues[0] &&
- aValues[1] == theValues[1] &&
- aValues[2] == theValues[2];
- }
- return isFound;
-}
-
-std::vector<int> HSVtoRGB(int theH, int theS, int theV)
-{
- std::vector<int> aRGB;
- if (theH < 0 || theH > 360 ||
- theS < 0 || theS > 100 ||
- theV < 0 || theV > 100)
- return aRGB;
-
- int aHi = (int)theH/60;
-
- double aV = theV;
- double aVmin = (100 - theS)*theV/100;
-
- double anA = (theV - aVmin)* (theH % 60) / 60;
-
- double aVinc = aVmin + anA;
- double aVdec = theV - anA;
-
- double aPercentToValue = 255./100;
- int aV_int = (int)(aV*aPercentToValue);
- int aVinc_int = (int)(aVinc*aPercentToValue);
- int aVmin_int = (int)(aVmin*aPercentToValue);
- int aVdec_int = (int)(aVdec*aPercentToValue);
-
- switch(aHi) {
- case 0: appendValues(aRGB, aV_int, aVinc_int, aVmin_int); break;
- case 1: appendValues(aRGB, aVdec_int, aV_int, aVmin_int); break;
- case 2: appendValues(aRGB, aVmin_int, aV_int, aVinc_int); break;
- case 3: appendValues(aRGB, aVmin_int, aVdec_int, aV_int); break;
- case 4: appendValues(aRGB, aVinc_int, aVmin_int, aV_int); break;
- case 5: appendValues(aRGB, aV_int, aVmin_int, aVdec_int); break;
- default: break;
- }
- return aRGB;
-}
-
-
-void fillColorMap()
-{
- if (!myColorMap.empty())
- return;
-
- int i = 0;
- for (int s = 100; s > 0; s = s - 50)
- {
- for (int v = 100; v >= 40; v = v - 20)
- {
- for (int h = 0; h < 359 ; h = h + 60)
- {
- std::vector<int> aColor = HSVtoRGB(h, s, v);
- if (containsValues(myColorMap, aColor))
- continue;
- myColorMap[i] = aColor;
- i++;
- }
- }
- }
-}
-
-void findRandomColor(std::vector<int>& theValues)
-{
- theValues.clear();
- if (myColorMap.empty()) {
- fillColorMap();
- }
-
- size_t aSize = myColorMap.size();
- int anIndex = rand() % aSize;
- if (myColorMap.find(anIndex) != myColorMap.end()) {
- theValues = myColorMap.at(anIndex);
- }
-}
std::vector<int> XGUI_ColorDialog::getRandomColor() const
{
std::vector<int> aValues;
if (isRandomColor()) {
- findRandomColor(aValues);
+ ModelAPI_Tools::findRandomColor(aValues);
}
return aValues;
}
+
aAction = ModuleBase_Tools::createAction(QIcon(":pictures/color.png"), tr("Color..."), aDesktop);
addAction("COLOR_CMD", aAction);
+ aAction = ModuleBase_Tools::createAction(QIcon(""), tr("Auto color"), aDesktop);
+ addAction("AUTOCOLOR_CMD", aAction);
+
aAction = ModuleBase_Tools::createAction(QIcon(""), tr("Deflection..."), aDesktop);
addAction("DEFLECTION_CMD", aAction);
action("COLOR_CMD")->setEnabled(myWorkshop->canChangeProperty("COLOR_CMD"));
action("DEFLECTION_CMD")->setEnabled(myWorkshop->canChangeProperty("DEFLECTION_CMD"));
action("TRANSPARENCY_CMD")->setEnabled(myWorkshop->canChangeProperty("TRANSPARENCY_CMD"));
+ action("AUTOCOLOR_CMD")->setEnabled(myWorkshop->canChangeProperty("AUTOCOLOR_CMD"));
+
#ifdef _DEBUG
#ifdef TINSPECTOR
action("TINSPECTOR_VIEW")->setEnabled(true);
aList.append(action("DELETE_CMD"));
myObjBrowserMenus[ModelAPI_ResultBody::group()] = aList;
// Group menu
- myObjBrowserMenus[ModelAPI_ResultGroup::group()] = aList;
myObjBrowserMenus[ModelAPI_ResultField::group()] = aList;
// Result part menu
myObjBrowserMenus[ModelAPI_ResultPart::group()] = aList;
+
+ aList.clear();
+ aList.append(action("WIREFRAME_CMD"));
+ aList.append(action("SHADING_CMD"));
+ aList.append(mySeparator1); // this separator is not shown as this action is added after show only
+ // qt list container contains only one instance of the same action
+ aList.append(action("SHOW_CMD"));
+ aList.append(action("HIDE_CMD"));
+ aList.append(action("SHOW_ONLY_CMD"));
+ aList.append(mySeparator2);
+ aList.append(action("AUTOCOLOR_CMD"));
+ aList.append(action("RENAME_CMD"));
+ aList.append(action("COLOR_CMD"));
+ aList.append(action("DEFLECTION_CMD"));
+ aList.append(action("TRANSPARENCY_CMD"));
+ aList.append(action("SHOW_ISOLINES_CMD"));
+ aList.append(action("ISOLINES_CMD"));
+ aList.append(action("SHOW_FEATURE_CMD"));
+ aList.append(mySeparator3);
+ aList.append(action("DELETE_CMD"));
+ // Group menu
+ myObjBrowserMenus[ModelAPI_ResultGroup::group()] = aList;
//-------------------------------------
// Feature menu
aList.clear();
#include <QSpinBox>
#include <QDialogButtonBox>
+#include <sstream>
#include <iterator>
#ifdef TINSPECTOR
moveObjects(theId == "MOVE_SPLIT_CMD");
else if (theId == "COLOR_CMD")
changeColor(aObjects);
+ else if (theId == "AUTOCOLOR_CMD")
+ changeAutoColor(aObjects);
else if (theId == "ISOLINES_CMD")
changeIsoLines(aObjects);
else if (theId == "SHOW_ISOLINES_CMD") {
return hasResults(aObjects, aTypes);
}
+ if (theActionName == "AUTOCOLOR_CMD") {
+
+ QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+
+ std::set<std::string> aTypes;
+ aTypes.insert(ModelAPI_ResultGroup::group());
+
+ return hasResults(aObjects, aTypes);
+ }
return false;
}
// 3. abort the previous operation and start a new one
SessionPtr aMgr = ModelAPI_Session::get();
QString aDescription = contextMenuMgr()->action("COLOR_CMD")->text();
+
aMgr->startOperation(aDescription.toStdString());
// 4. set the value to all results
myViewerProxy->update();
}
+//**************************************************************
+void XGUI_Workshop::changeAutoColor(const QObjectPtrList& theObjects)
+{
+ if (!abortAllOperations())
+ return;
+
+ std::vector<int> aColor;
+
+ // abort the previous operation and start a new one
+ SessionPtr aMgr = ModelAPI_Session::get();
+ QString aDescription = contextMenuMgr()->action("AUTOCOLOR_CMD")->text();
+ aMgr->startOperation(aDescription.toStdString());
+
+ Config_Prop* aProp = Config_PropManager::findProp("Visualization", "result_group_Auto_color");
+
+ if (aProp) {
+ bool anIsAutoColor = Config_PropManager::boolean("Visualization", "result_group_Auto_color");
+
+ if (anIsAutoColor) {
+ contextMenuMgr()->action("AUTOCOLOR_CMD")->setText(tr("Auto color"));
+ aProp->setValue("false");
+ } else {
+ // set the value to all results
+ foreach (ObjectPtr anObj, theObjects) {
+ DocumentPtr aDocument = anObj->document();
+ std::list<FeaturePtr> anAllFeatures = allFeatures(aDocument);
+ // find the object iterator
+ std::list<FeaturePtr>::iterator aObjectIt = anAllFeatures.begin();
+ for (; aObjectIt != anAllFeatures.end(); ++ aObjectIt) {
+ FeaturePtr aFeature = *aObjectIt;
+ if (aFeature.get()) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aIt;
+ for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
+ ResultPtr aGroupResult = *aIt;
+ if (aGroupResult.get() &&
+ aGroupResult->groupName() == ModelAPI_ResultGroup::group()) {
+ ModelAPI_Tools::findRandomColor(aColor);
+ ModelAPI_Tools::setColor(aGroupResult, aColor);
+ }
+ }
+ }
+ }
+ }
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ aMgr->finishOperation();
+ updateCommandStatus();
+ myViewerProxy->update();
+ contextMenuMgr()->action("AUTOCOLOR_CMD")->setText(tr("Disable auto color"));
+ aProp->setValue("true");
+ }
+ }
+}
+
//**************************************************************
void setTransparency(double theTransparency, const QObjectPtrList& theObjects)
{
/// theObjects a list of selected objects
void changeColor(const QObjectPtrList& theObjects);
+ /// Change Autocolor of the results if it is possible
+ /// The operation is available for group results
+ /// theObjects a list of selected objects
+ void changeAutoColor(const QObjectPtrList& theObjects);
+
/// Change deflection of the results if it is possible
/// The operation is available for construction, body and group results
/// theObjects a list of selected objects
/// Sets the granted operations for the parameter operation. Firstly, it finds the nested features
/// and set them into the operation. Secondly, it asks the module about ids of granted operations.
/// \param theOperation an operation
- void setGrantedFeatures(ModuleBase_Operation* theOperation);
+ void setGrantedFeatures(ModuleBase_Operation* theOperation);
private:
/// Display results from document
