//purpose :
//==============================================================================
-const Handle(Standard_Transient)& ViewerTest::WClass()
+const Handle(WNT_WClass)& ViewerTest::WClass()
{
- static Handle(Standard_Transient) theWClass;
+ static Handle(WNT_WClass) theWClass;
#if defined(_WIN32)
if (theWClass.IsNull())
{
// Create window
#if defined(_WIN32)
- VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
- Handle(WNT_WClass)::DownCast (WClass()),
+ VT_GetWindow() = new WNT_Window (aTitle.ToCString(), WClass(),
Draw_VirtualWindows ? WS_POPUP : WS_OVERLAPPEDWINDOW,
aPxLeft, aPxTop,
aPxWidth, aPxHeight,
}
else
{
- std::cout << "Syntax error: unknown argument " << anArg << ".\n";
+ Message::SendFail() << "Syntax error: unknown argument " << anArg;
return 1;
}
}
}
else
{
- std::cout << "Syntax error: unknown argument " << anArg << ".\n";
+ Message::SendFail() << "Syntax error: unknown argument " << anArg;
return 1;
}
}
if (!aDisplayName.IsEmpty())
{
aDisplayName.Clear();
- std::cout << "Warning: display parameter will be ignored.\n";
+ Message::SendWarning() << "Warning: display parameter will be ignored.\n";
}
#endif
const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
if (aView.IsNull())
{
- std::cerr << "Error: No opened viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << argv[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << argv[anArgIter] << "'";
return 1;
}
}
const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
if (aView.IsNull())
{
- std::cerr << "Error: No opened viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
TCollection_AsciiString aName (argv[anArgIter]);
if (!aMap.IsBound2 (aName))
{
- std::cout << "Syntax error: Wrong shape name '" << aName << "'.\n";
+ Message::SendFail() << "Syntax error: Wrong shape name '" << aName << "'";
return 1;
}
Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (aMap.Find2 (aName));
if (aShape.IsNull())
{
- std::cout << "Syntax error: '" << aName << "' is not a shape presentation.\n";
+ Message::SendFail() << "Syntax error: '" << aName << "' is not a shape presentation";
return 1;
}
aListOfShapes.Append (aShape);
}
if (aTypeOfHLR == Prs3d_TOH_NotSet)
{
- std::cout << "Syntax error: wrong number of arguments!\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
{
if (!ViewerTest_myViews.IsBound1(theViewName))
{
- std::cout << "Wrong view name\n";
+ Message::SendFail() << "Wrong view name";
return;
}
ViewerTest_myContexts.UnBind2(aCurrentContext);
}
}
- std::cout << "3D View - " << theViewName << " was deleted.\n";
+ Message::SendInfo() << "3D View - " << theViewName << " was deleted.\n";
if (ViewerTest_EventManager::ToExitOnCloseView())
{
Draw_Interprete ("exit");
ViewerTest_Names aViewName (theArgVec[1]);
if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
{
- std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
+ Message::SendFail() << "Error: the view with name '" << theArgVec[1] << "' does not exist";
return 1;
}
aViewList.Append (aViewName.GetViewName());
// close active view
if (ViewerTest::CurrentView().IsNull())
{
- std::cerr << "No active view!\n";
+ Message::SendFail ("Error: no active view");
return 1;
}
aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
}
else if (aNameString.IsEmpty())
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active view\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
gp_Dir aRight, anUp;
if (aFrameDef.Value (2) == aFrameDef.Value (4))
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (!isGeneralCmd
&& theNbArgs != 1)
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
return 0;
}
if (aDispConn.IsNull())
{
- std::cerr << "Error: ViewerTest is unable processing messages for unknown X Display\n";
+ Message::SendFail ("Error: ViewerTest is unable processing messages for unknown X Display");
return;
}
const Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
}
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << theArgVec[0] << "Error: No active view.\n";
+ Message::SendFail ("Error: No active viewer");
return 1;
}
}
else
{
- std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
+ Message::SendFail ("Syntax error: Invalid number of arguments");
theDI.PrintHelp(theArgVec[0]);
return 1;
}
if (aDiagonal < Precision::Confusion())
{
- std::cerr << theArgVec[0] << "Error: view area is too small.\n";
+ Message::SendFail ("Error: view area is too small");
return 1;
}
if (aCurrentView.IsNull())
{
- std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
if (theNbArgs < 4)
{
- std::cout << "Syntax error: Invalid number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'";
}
}
else if (aFlag == "-scale")
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
aLabelsColor);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
anArrowColorX);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
anArrowColorY);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
anArrowColorZ);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
}
else
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "No active view!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
hasFlags = Standard_True;
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
hasFlags = Standard_True;
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
else if (theArgNb != 4
&& theArgNb != 7)
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
return 0;
}
- std::cout << "Error: Invalid number of arguments\n";
+ Message::SendFail ("Error: Invalid number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << theArgs[0] << "Error: no active view." << std::endl;
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (theArgNb != 3)
{
- std::cerr << theArgs[0] << "Error: invalid number of arguments." << std::endl;
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aContext.IsNull())
{
- std::cout << "Error: no active view!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (theArgNb <= 1)
{
- std::cout << "Error: wrong syntax at command '" << theArgVec[0] << "'!\n";
+ Message::SendFail() << "Error: wrong syntax at command '" << theArgVec[0] << "'";
return 1;
}
aColorScale = Handle(AIS_ColorScale)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
if (aColorScale.IsNull())
{
- std::cout << "Error: object '" << theArgVec[1] << "'is already defined and is not a color scale!\n";
+ Message::SendFail() << "Error: object '" << theArgVec[1] << "'is already defined and is not a color scale";
return 1;
}
}
{
if (aColorScale.IsNull())
{
- std::cout << "Syntax error: colorscale with a given name does not exist.\n";
+ Message::SendFail() << "Syntax error: colorscale with a given name does not exist";
return 1;
}
{
if (anArgIter + 3 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Error: wrong syntax at argument '" << anArg << "'";
return 1;
}
if (!aRangeMin.IsRealValue()
|| !aRangeMax.IsRealValue())
{
- std::cout << "Error: the range values should be real!\n";
+ Message::SendFail ("Syntax error: the range values should be real");
return 1;
}
else if (!aNbIntervals.IsIntegerValue())
{
- std::cout << "Error: the number of intervals should be integer!\n";
+ Message::SendFail ("Syntax error: the number of intervals should be integer");
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
TCollection_AsciiString aFontArg(theArgVec[anArgIter + 1]);
if (!aFontArg.IsIntegerValue())
{
- std::cout << "Error: HeightFont value should be integer!\n";
+ Message::SendFail ("Syntax error: HeightFont value should be integer");
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: unknown position '" << aTextPosArg << "'!\n";
+ Message::SendFail() << "Syntax error: unknown position '" << aTextPosArg << "'";
return 1;
}
aColorScale->SetLabelPosition (aLabPosition);
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Synta error at argument '" << anArg << "'";
return 1;
}
Standard_Boolean IsLog;
if (!ViewerTest::ParseOnOff(theArgVec[++anArgIter], IsLog))
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aColorScale->SetLogarithmic (IsLog);
{
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (aNbParsed1 == 0
|| aNbParsed2 == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (!anX.IsIntegerValue()
|| !anY.IsIntegerValue())
{
- std::cout << "Error: coordinates should be integer values!\n";
+ Message::SendFail ("Syntax error: coordinates should be integer values");
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString aBreadth (theArgVec[++anArgIter]);
if (!aBreadth.IsIntegerValue())
{
- std::cout << "Error: a width should be an integer value!\n";
+ Message::SendFail ("Syntax error: a width should be an integer value");
return 1;
}
aColorScale->SetBreadth (aBreadth.IntegerValue());
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString aHeight (theArgVec[++anArgIter]);
if (!aHeight.IsIntegerValue())
{
- std::cout << "Error: a width should be an integer value!\n";
+ Message::SendFail ("Syntax error: a width should be an integer value");
return 1;
}
aColorScale->SetHeight (aHeight.IntegerValue());
{
if (aColorScale->GetColorType() != Aspect_TOCSD_USER)
{
- std::cout << "Error: wrong color type! Call -colors before to set user-specified colors!\n";
+ Message::SendFail ("Syntax error: wrong color type. Call -colors before to set user-specified colors");
return 1;
}
else if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString anInd (theArgVec[++anArgIter]);
if (!anInd.IsIntegerValue())
{
- std::cout << "Error: Index value should be integer!\n";
+ Message::SendFail ("Syntax error: Index value should be integer");
return 1;
}
const Standard_Integer anIndex = anInd.IntegerValue();
if (anIndex <= 0 || anIndex > aColorScale->GetNumberOfIntervals())
{
- std::cout << "Error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals() <<"!\n";
+ Message::SendFail() << "Syntax error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals();
return 1;
}
aColor);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
aColorScale->SetIntervalColor (aColor, anIndex);
{
if (aColorScale->GetColorType() != Aspect_TOCSD_USER)
{
- std::cout << "Error: wrong label type! Call -labels before to set user-specified labels!\n";
+ Message::SendFail ("Syntax error: wrong label type. Call -labels before to set user-specified labels");
return 1;
}
else if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
if (anIndex <= 0 || anIndex > aColorScale->GetNumberOfIntervals() + 1)
{
- std::cout << "Error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals() + 1 <<"!\n";
+ Message::SendFail() << "Syntax error: Index value should be within range 1.." << (aColorScale->GetNumberOfIntervals() + 1);
return 1;
}
}
if (aLabAtBorder == -1)
{
- std::cout << "Syntax error at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
toEnable = (aLabAtBorder == 1);
}
if (aSeq.Length() != aColorScale->GetNumberOfIntervals())
{
- std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
- << aColorScale->GetNumberOfIntervals() << " intervals\n";
+ Message::SendFail() << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+ << aColorScale->GetNumberOfIntervals() << " intervals";
return 1;
}
aColorScale->SetColors (aSeq);
aColorScale->SetColorType (Aspect_TOCSD_USER);
}
+ else if (aFlag == "-uniform")
+ {
+ const Standard_Real aLightness = Draw::Atof (theArgVec[++anArgIter]);
+ const Standard_Real aHueStart = Draw::Atof (theArgVec[++anArgIter]);
+ const Standard_Real aHueEnd = Draw::Atof (theArgVec[++anArgIter]);
+ aColorScale->SetUniformColors (aLightness, aHueStart, aHueEnd);
+ aColorScale->SetColorType (Aspect_TOCSD_USER);
+ }
else if (aFlag == "-labels"
|| aFlag == "-freelabels")
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Syntax error at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
if (anArgIter + aNbLabels >= theArgNb)
{
- std::cout << "Error: not enough arguments! " << aNbLabels << " text labels are expected.\n";
+ Message::SendFail() << "Syntax error: not enough arguments. " << aNbLabels << " text labels are expected";
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (!anArg1.IsRealValue())
{
- std::cout << "Error: the value should be real!\n";
+ Message::SendFail ("Syntax error: the value should be real");
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at " << anArg << " - unknown argument!\n";
+ Message::SendFail() << "Syntax error at " << anArg << " - unknown argument";
return 1;
}
}
{
if (theArgNum < 2)
{
- std::cout << theArgs[0] << " error: wrong number of parameters. Type 'help"
- << theArgs[0] <<"' for more information.\n";
- return 1; //TCL_ERROR
+ Message::SendFail() << "Syntax error: wrong number of parameters. Type 'help"
+ << theArgs[0] <<"' for more information";
+ return 1;
}
NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
aLowerKey = "-";
aLowerKey += aKey;
aLowerKey.LowerCase();
- std::cout << theArgs[0] << ": " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n";
- std::cout << "Type help for more information.\n";
+ Message::SendFail() << "Syntax error: " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n"
+ << "Type help for more information";
return 1;
}
Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
if (anAISContext.IsNull())
{
- std::cout << theArgs[0] << ": please use 'vinit' command to initialize view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -xnamecolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -xnamecolor wrong color name");
return 1;
}
aTrihedronData.ChangeXAxisAspect().SetNameColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -ynamecolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -ynamecolor wrong color name");
return 1;
}
aTrihedronData.ChangeYAxisAspect().SetNameColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -znamecolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -znamecolor wrong color name");
return 1;
}
aTrihedronData.ChangeZAxisAspect().SetNameColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -xcolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -xcolor wrong color name");
return 1;
}
aTrihedronData.ChangeXAxisAspect().SetColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -ycolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -ycolor wrong color name");
return 1;
}
aTrihedronData.ChangeYAxisAspect().SetColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -zcolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -zcolor wrong color name");
return 1;
}
aTrihedronData.ChangeZAxisAspect().SetColor (aColor);
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (anArgIter + 3 < theArgNb)
{
- std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
aTile.IsTopDown = (anArg == "-upperleft") == Standard_True;
{
if (anArgIter + 3 < theArgNb)
{
- std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
aTile.TotalSize.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
if (aTile.TotalSize.x() < 1
|| aTile.TotalSize.y() < 1)
{
- std::cerr << "Error: total size is incorrect.\n";
+ Message::SendFail ("Error: total size is incorrect");
return 1;
}
}
{
if (anArgIter + 3 < theArgNb)
{
- std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
if (aTile.TileSize.x() < 1
|| aTile.TileSize.y() < 1)
{
- std::cerr << "Error: tile size is incorrect.\n";
+ Message::SendFail ("Error: tile size is incorrect");
return 1;
}
}
if (aTile.TileSize.x() < 1
|| aTile.TileSize.y() < 1)
{
- std::cerr << "Error: tile size is undefined.\n";
+ Message::SendFail ("Error: tile size is undefined");
return 1;
}
else if (aTile.TotalSize.x() < 1
|| aTile.TotalSize.y() < 1)
{
- std::cerr << "Error: total size is undefined.\n";
+ Message::SendFail ("Error: total size is undefined");
return 1;
}
Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
if (aContextAIS.IsNull())
{
- std::cout << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
aLayerId = Graphic3d_ZLayerId_UNKNOWN;
if (!aViewer->AddZLayer (aLayerId))
{
- std::cout << "Error: can not add a new z layer!\n";
+ Message::SendFail ("Error: can not add a new z layer");
return 0;
}
aLayerId = Graphic3d_ZLayerId_UNKNOWN;
if (!aViewer->InsertLayerBefore (aLayerId, Graphic3d_ZLayerSettings(), anOtherLayerId))
{
- std::cout << "Error: can not add a new z layer!\n";
+ Message::SendFail ("Error: can not add a new z layer");
return 0;
}
aLayerId = Graphic3d_ZLayerId_UNKNOWN;
if (!aViewer->InsertLayerAfter (aLayerId, Graphic3d_ZLayerSettings(), anOtherLayerId))
{
- std::cout << "Error: can not add a new z layer!\n";
+ Message::SendFail ("Error: can not add a new z layer");
return 0;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: id of z layer to remove is missing\n";
+ Message::SendFail ("Syntax error: id of z layer to remove is missing");
return 1;
}
|| aLayerId == Graphic3d_ZLayerId_TopOSD
|| aLayerId == Graphic3d_ZLayerId_BotOSD)
{
- std::cout << "Syntax error: standard Z layer can not be removed\n";
+ Message::SendFail ("Syntax error: standard Z layer can not be removed");
return 1;
}
if (!aViewer->RemoveZLayer (aLayerId))
{
- std::cout << "Z layer can not be removed!\n";
+ Message::SendFail ("Z layer can not be removed");
}
else
{
{
if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: name is missing\n";
+ Message::SendFail ("Syntax error: name is missing");
return 1;
}
{
if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Syntax error: origin coordinates are missing\n";
+ Message::SendFail ("Syntax error: origin coordinates are missing");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
|| anArg == "enable";
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: option name is missing\n";
+ Message::SendFail ("Syntax error: option name is missing");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
{
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Syntax error: factor and units values for depth offset are missing\n";
+ Message::SendFail ("Syntax error: factor and units values for depth offset are missing");
return 1;
}
}
else
{
- std::cout << "Syntax error: unknown option " << theArgVec[anArgIter] << "\n";
+ Message::SendFail() << "Syntax error: unknown option " << theArgVec[anArgIter];
return 1;
}
}
if (argc > 6
&& !ViewerTest::ParseLineType (argv[6], aLineType))
{
- std::cout << "Syntax error: unknown line type '" << argv[6] << "'\n";
+ Message::SendFail() << "Syntax error: unknown line type '" << argv[6] << "'";
return 1;
}
Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
if (aView.IsNull() || aViewer.IsNull())
{
- std::cerr << "Error: no active view\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArgNext << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArgNext << "'";
return 1;
}
}
}
else
{
- std::cout << "Syntax error at '" << anArgNext << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArgNext << "'";
return 1;
}
}
if (aNewStepXY.x() <= 0.0
|| aNewStepXY.y() <= 0.0)
{
- std::cout << "Syntax error: wrong step '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'\n";
+ Message::SendFail() << "Syntax error: wrong step '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'";
return 1;
}
anArgIter += 2;
aNewSizeXY.SetValues (Draw::Atof (theArgVec[anArgIter]), 0.0);
if (aNewStepXY.x() <= 0.0)
{
- std::cout << "Syntax error: wrong size '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error: wrong size '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (aNewStepXY.x() <= 0.0
|| aNewStepXY.y() <= 0.0)
{
- std::cout << "Syntax error: wrong size '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'\n";
+ Message::SendFail() << "Syntax error: wrong size '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'";
return 1;
}
anArgIter += 2;
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
aDivisionNumber = (int )aNewStepXY[1];
if (aDivisionNumber < 1)
{
- std::cout << "Syntax error: invalid division number '" << aNewStepXY[1] << "'\n";
+ Message::SendFail() << "Syntax error: invalid division number '" << aNewStepXY[1] << "'";
return 1;
}
}
aRadius = aNewSizeXY.x();
if (aNewSizeXY.y() != 0.0)
{
- std::cout << "Syntax error: circular size should be specified as radius\n";
+ Message::SendFail ("Syntax error: circular size should be specified as radius");
return 1;
}
}
{
if (theArgNb != 1 && theArgNb != 7 && theArgNb != 10)
{
- std::cerr << "Error: wrong number of arguments! See usage:\n";
+ Message::SendFail ("Error: wrong number of arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
if (aViewer.IsNull())
{
- std::cerr << "Error: no active viewer. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
// non-numeric argument too early
if (aCoord.IsEmpty())
{
- std::cerr << "Error: wrong number of arguments! See usage:\n";
+ Message::SendFail ("Error: wrong number of arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
else if (anArg == "ray") aMode = Ray;
else
{
- std::cerr << "Error: wrong argument " << anArg << "! See usage:\n";
+ Message::SendFail() << "Error: wrong argument " << anArg << "! See usage:";
theDI.PrintHelp (theArgVec[0]);
return 1;
}
(aCoord.Length() == 2 && theArgNb > 4) ||
(aCoord.Length() == 3 && theArgNb > 5))
{
- std::cerr << "Error: wrong number of arguments! See usage:\n";
+ Message::SendFail ("Error: wrong number of arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
case View : theDI << "View Vv: " << aView->Convert ((Standard_Integer)aCoord (1)); return 0;
case Window : theDI << "Window Vp: " << aView->Convert (aCoord (1)); return 0;
default:
- std::cerr << "Error: wrong arguments! See usage:\n";
+ Message::SendFail ("Error: wrong arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
return 0;
default:
- std::cerr << "Error: wrong arguments! See usage:\n";
+ Message::SendFail ("Error: wrong arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
return 0;
default:
- std::cerr << "Error: wrong arguments! See usage:\n";
+ Message::SendFail ("Error: wrong arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
aFramesNb = anArg.IntegerValue();
if (aFramesNb <= 0)
{
- std::cerr << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
}
else
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
{
if (!toSet)
{
- std::cerr << "No active view!\n";
+ Message::SendFail ("Error: no active viewer");
}
return 1;
}
if (aVer[0] < -1
|| aVer[1] < -1)
{
- std::cout << "Syntax error at '" << anArgCase << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArgCase << "'";
return 1;
}
aCaps->contextMajorVersionUpper = aVer[0];
}
else
{
- std::cout << "Error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Error: unknown argument '" << anArg << "'";
return 1;
}
}
Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
if (aContextAIS.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
if (aDriver.IsNull())
{
- std::cerr << "Graphic driver not available.\n";
+ Message::SendFail ("Error: graphic driver not available");
return 1;
}
TCollection_AsciiString anInfo;
if (!aDriver->MemoryInfo (aFreeBytes, anInfo))
{
- std::cerr << "Information not available.\n";
+ Message::SendFail ("Error: information not available");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (theArgNb < 3)
{
- std::cerr << "Usage : " << theArgVec[0] << " xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]\n";
+ Message::SendFail() << "Syntax error: wrong number of arguments.\n"
+ << "Usage: " << theArgVec[0] << " xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]";
return 1;
}
const Standard_Integer anY = Draw::Atoi (theArgVec[2]);
if (anX < 0 || anX >= aWidth || anY < 0 || anY > aHeight)
{
- std::cerr << "Pixel coordinates (" << anX << "; " << anY << ") are out of view (" << aWidth << " x " << aHeight << ")\n";
+ Message::SendFail() << "Error: pixel coordinates (" << anX << "; " << anY << ") are out of view (" << aWidth << " x " << aHeight << ")";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << aParam << "'\n";
+ Message::SendFail() << "Syntax error at '" << aParam << "'";
return 1;
}
}
Image_PixMap anImage;
if (!anImage.InitTrash (aFormat, aWidth, aHeight))
{
- std::cerr << "Image allocation failed\n";
+ Message::SendFail ("Error: image allocation failed");
return 1;
}
else if (!aView->ToPixMap (anImage, aWidth, aHeight, aBufferType))
{
- std::cerr << "Image dump failed\n";
+ Message::SendFail ("Error: image dump failed");
return 1;
}
{
if (theArgNb < 3)
{
- std::cout << "Syntax error: not enough arguments.\n";
+ Message::SendFail ("Syntax error: not enough arguments");
return 1;
}
aTolColor = Atof (theArgVec[++anArgIter]);
if (aTolColor < 0.0 || aTolColor > 1.0)
{
- std::cout << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'";
return 1;
}
}
aTolColor = anArg.RealValue();
if (aTolColor < 0.0 || aTolColor > 1.0)
{
- std::cout << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'";
return 1;
}
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
Handle(Image_AlienPixMap) anImgNew = new Image_AlienPixMap();
if (!anImgRef->Load (anImgPathRef))
{
- std::cout << "Error: image file '" << anImgPathRef << "' cannot be read\n";
+ Message::SendFail() << "Error: image file '" << anImgPathRef << "' cannot be read";
return 1;
}
if (!anImgNew->Load (anImgPathNew))
{
- std::cout << "Error: image file '" << anImgPathNew << "' cannot be read\n";
+ Message::SendFail() << "Error: image file '" << anImgPathNew << "' cannot be read";
return 1;
}
aDiff = new Image_AlienPixMap();
if (!aDiff->InitTrash (Image_Format_Gray, anImgRef->SizeX(), anImgRef->SizeY()))
{
- std::cout << "Error: cannot allocate memory for diff image " << anImgRef->SizeX() << "x" << anImgRef->SizeY() << "\n";
+ Message::SendFail() << "Error: cannot allocate memory for diff image " << anImgRef->SizeX() << "x" << anImgRef->SizeY();
return 1;
}
aComparer.SaveDiffImage (*aDiff);
if (!aDiffImagePath.IsEmpty()
&& !aDiff->Save (aDiffImagePath))
{
- std::cout << "Error: diff image file '" << aDiffImagePath << "' cannot be written\n";
+ Message::SendFail() << "Error: diff image file '" << aDiffImagePath << "' cannot be written";
return 1;
}
}
const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull())
{
- std::cout << "Error: no active View\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
- if (toAllowOverlap
- && aPnts.Length() != 2)
- {
- std::cout << "Syntax error: -allowoverlap key is applied only for rectangle selection\n";
- return 1;
- }
+
if (toAllowOverlap)
{
aCtx->MainSelector()->AllowOverlapDetection (toAllowOverlap);
const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aContext.IsNull())
{
- std::cout << "Error: no active View\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (anArgIter + 1 < theNbArgs)
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter + 1] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter + 1] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (aMousePos.x() == IntegerLast()
|| aMousePos.y() == IntegerLast())
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << theArgVec[0] << ": please initialize or activate view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
Handle(ViewerTest_V3dView) aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest::CurrentView());
if (aV3dView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
TCollection_AsciiString aViewName = aViewNames.GetViewName();
if (!ViewerTest_myViews.IsBound1 (aViewName))
{
- std::cout << "Syntax error: unknown view '" << theArgVec[anArgIt - 1] << "'.\n";
+ Message::SendFail() << "Syntax error: unknown view '" << theArgVec[anArgIt - 1] << "'";
return 1;
}
aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest_myViews.Find1 (aViewName));
}
else
{
- std::cout << "Syntax error: unknown argument " << anArg << ".\n";
+ Message::SendFail() << "Syntax error: unknown argument " << anArg;
return 1;
}
}
}
if (aCtx.IsNull())
{
- std::cout << "Error: no active view\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
TCollection_AsciiString aNameArg (theArgVec[anArgIter++]);
if (aNameArg.IsEmpty())
{
- std::cout << "Syntax error: animation name is not defined.\n";
+ Message::SendFail ("Syntax error: animation name is not defined");
return 1;
}
}
else if (aNameArg.Value (1) == '-')
{
- std::cout << "Syntax error: invalid animation name '" << aNameArg << "'.\n";
+ Message::SendFail() << "Syntax error: invalid animation name '" << aNameArg << "'";
return 1;
}
{
if (aSplitPos == aNameArg.Length())
{
- std::cout << "Syntax error: animation name is not defined.\n";
+ Message::SendFail ("Syntax error: animation name is not defined");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg << "";
return 1;
}
aPlaySpeed = Draw::Atof (theArgVec[anArgIter]);
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.FpsDen = aDenStr.IntegerValue();
if (aRecParams.FpsDen < 1)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.Format = theArgVec[anArgIter];
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.PixelFormat = theArgVec[anArgIter];
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.VideoCodec = theArgVec[anArgIter];
const TCollection_AsciiString aParamName = anArg.SubString (2, anArg.Length());
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
Handle(AIS_InteractiveObject) anObject;
if (!aMapOfAIS.Find2 (anObjName, anObject))
{
- std::cout << "Syntax error: wrong object name at " << anArg << "\n";
+ Message::SendFail() << "Syntax error: wrong object name at " << anArg;
return 1;
}
if (aTrsfArgIter + 4 >= theArgNb
|| !parseQuaternion (theArgVec + aTrsfArgIter + 1, aRotQuats[anIndex]))
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
aTrsfArgIter += 4;
if (aTrsfArgIter + 3 >= theArgNb
|| !parseXYZ (theArgVec + aTrsfArgIter + 1, aLocPnts[anIndex]))
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
aTrsfArgIter += 3;
isTrsfSet = Standard_True;
if (++aTrsfArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
const TCollection_AsciiString aScaleStr (theArgVec[aTrsfArgIter]);
if (!aScaleStr.IsRealValue())
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
aScales[anIndex] = aScaleStr.RealValue();
}
if (!isTrsfSet)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
else if (aTrsfArgIter >= theArgNb)
isTrsfSet = Standard_True;
if (++aViewArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
const TCollection_AsciiString aScaleStr (theArgVec[aViewArgIter]);
if (!aScaleStr.IsRealValue())
{
- std::cout << "Syntax error at " << aViewArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aViewArg;
return 1;
}
Standard_Real aScale = aScaleStr.RealValue();
if (aViewArgIter + 3 >= theArgNb
|| !parseXYZ (theArgVec + aViewArgIter + 1, anXYZ))
{
- std::cout << "Syntax error at " << aViewArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aViewArg;
return 1;
}
aViewArgIter += 3;
}
if (!isTrsfSet)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
else if (aViewArgIter >= theArgNb)
}
else
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
}
aRecorder = new Image_VideoRecorder();
if (!aRecorder->Open (aRecFile.ToCString(), aRecParams))
{
- std::cout << "Error: failed to open video file for recording\n";
+ Message::SendFail ("Error: failed to open video file for recording");
return 0;
}
aDumpParams.ToAdjustAspect = Standard_True;
if (!aView->ToPixMap (aRecorder->ChangeFrame(), aDumpParams))
{
- std::cout << "Error: view dump is failed!\n";
+ Message::SendFail ("Error: view dump is failed");
return 0;
}
aFlipper.FlipY (aRecorder->ChangeFrame());
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (!isOk)
{
- std::cerr << "Usage :" << std::endl;
- std::cerr << theArgVec[0] << " off" << std::endl;
- std::cerr << theArgVec[0] << " on {index_of_std_texture(0..7)|texture_file_name} [{clamp|repeat} {decal|modulate} {nearest|bilinear|trilinear} scale_s scale_t translation_s translation_t rotation_degrees]" << std::endl;
+ Message::SendFail() << "Usage:\n"
+ << theArgVec[0] << " off\n"
+ << theArgVec[0] << " on {index_of_std_texture(0..7)|texture_file_name} [{clamp|repeat} {decal|modulate} {nearest|bilinear|trilinear} scale_s scale_t translation_s translation_t rotation_degrees]";
return 1;
}
Handle(Graphic3d_ClipPlane) aClipPlane;
if (!theRegPlanes.Find (theName, aClipPlane))
{
- std::cout << "Warning: no such plane.\n";
+ Message::SendWarning ("Warning: no such plane");
return;
}
const Handle(V3d_View)& anActiveView = ViewerTest::CurrentView();
if (anActiveView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (theArgsNb < 3)
{
- std::cout << "Syntax error: plane name is required.\n";
+ Message::SendFail ("Syntax error: plane name is required");
return 1;
}
{
if (!aRegPlanes.IsBound (aPlane))
{
- std::cout << "Error: no such plane.\n";
+ Message::SendFail ("Error: no such plane");
return 1;
}
else if (theArgsNb < 4)
{
- std::cout << "Syntax error: enter name for new plane.\n";
+ Message::SendFail ("Syntax error: enter name for new plane");
return 1;
}
TCollection_AsciiString aClone (theArgVec[3]);
if (aRegPlanes.IsBound (aClone))
{
- std::cout << "Error: plane name is in use.\n";
+ Message::SendFail ("Error: plane name is in use");
return 1;
}
{
if (theArgsNb < 5)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
// old syntax support
if (theArgsNb < 3)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
aPlaneName = theArgVec[2];
if (!aRegPlanes.Find (aPlaneName, aClipPlane))
{
- std::cout << "Error: no such plane '" << aPlaneName << "'.\n";
+ Message::SendFail() << "Error: no such plane '" << aPlaneName << "'";
return 1;
}
}
if (theArgsNb - anArgIter < 1)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 5)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
if (!aSubStr.IsIntegerValue()
|| aSubStr.IntegerValue() <= 0)
{
- std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'";
return 1;
}
aSubIndex = aSubStr.IntegerValue();
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
aColor);
if (aNbParsed == 0)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
aClipPlane->SetCappingColor (aColor);
Graphic3d_NameOfMaterial aMatName;
if (!Graphic3d_MaterialAspect::MaterialFromName (aChangeArgs[1], aMatName))
{
- std::cout << "Syntax error: unknown material '" << aChangeArgs[1] << "'.\n";
+ Message::SendFail() << "Syntax error: unknown material '" << aChangeArgs[1] << "'";
return 1;
}
aClipPlane->SetCappingMaterial (aMatName);
}
else
{
- std::cout << "Syntax error at '" << aValStr << "'\n";
+ Message::SendFail() << "Syntax error at '" << aValStr << "'";
return 1;
}
anAspect->SetAlphaMode (aMode);
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aClipPlane->CappingTexture().IsNull())
{
- std::cout << "Error: no texture is set.\n";
+ Message::SendFail ("Error: no texture is set");
return 1;
}
if (aNbChangeArgs < 3)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aClipPlane->CappingTexture().IsNull())
{
- std::cout << "Error: no texture is set.\n";
+ Message::SendFail ("Error: no texture is set");
return 1;
}
if (aNbChangeArgs < 3)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aClipPlane->CappingTexture().IsNull())
{
- std::cout << "Error: no texture is set.\n";
+ Message::SendFail ("Error: no texture is set");
return 1;
}
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
}
else
{
- std::cout << "Error: object/view '" << anEntityName << "' is not found!\n";
+ Message::SendFail() << "Error: object/view '" << anEntityName << "' is not found";
return 1;
}
}
}
else
{
- std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'";
return 1;
}
}
if (aCurrentView.IsNull())
{
- std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (aNewZNear >= aNewZFar)
{
- std::cout << theArgVec[0] << ": invalid arguments: znear should be less than zfar.\n";
+ Message::SendFail ("Syntax error: invalid arguments: znear should be less than zfar");
return 1;
}
if (!aCamera->IsOrthographic() && (aNewZNear <= 0.0 || aNewZFar <= 0.0))
{
- std::cout << theArgVec[0] << ": invalid arguments: ";
- std::cout << "znear, zfar should be positive for perspective camera.\n";
+ Message::SendFail ("Syntax error: invalid arguments: znear, zfar should be positive for perspective camera");
return 1;
}
}
else
{
- std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
+ Message::SendFail ("Syntax error: wrong command arguments");
return 1;
}
if (aCurrentView.IsNull())
{
- std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (theArgsNb > 3)
{
- std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
+ Message::SendFail ("Syntax error: wrong command arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else if (*anArgValue != '-')
{
- std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
+ Message::SendFail() << "Error: unknown IOD type '" << anArgValue << "'";
return 1;
}
switch (aCamera->GetIODType())
}
else if (*anArgValue != '-')
{
- std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
+ Message::SendFail() << "Error: unknown ZFocus type '" << anArgValue << "'";
return 1;
}
switch (aCamera->ZFocusType())
}
else
{
- std::cout << "Error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Error: unknown argument '" << anArg << "'";
return 1;
}
}
aCameraFrustum = Handle(AIS_CameraFrustum)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
if (aCameraFrustum.IsNull())
{
- std::cout << "Error: object '" << aPrsName << "'is already defined and is not a camera frustum!\n";
+ Message::SendFail() << "Error: object '" << aPrsName << "'is already defined and is not a camera frustum";
return 1;
}
}
{
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 0;
}
{
if (++anArgIter < theArgNb)
{
- std::cout << "Error: wrong number of arguments!\n";
+ Message::SendFail ("Error: wrong number of arguments");
return 1;
}
{
if (++anArgIter < theArgNb)
{
- std::cout << "Error: wrong number of arguments!\n";
+ Message::SendFail ("Error: wrong number of arguments");
return 1;
}
if (++anArgIter >= theArgNb
|| !parseStereoMode (theArgVec[anArgIter], aMode))
{
- std::cout << "Error: syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
if (++anArgIter >= theArgNb
|| !parseAnaglyphFilter (theArgVec[anArgIter], aFilter))
{
- std::cout << "Error: syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull())
{
- std::cout << "Error: no active viewer\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
theDi << "DeflType: absolute\n"
<< "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
}
- theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
+ theDi << "AngularDeflection: " << (180.0 * aDefParams->DeviationAngle() / M_PI) << "\n";
theDi << "AutoTriangulation: " << (aDefParams->IsAutoTriangulation() ? "on" : "off") << "\n";
return 0;
}
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Error: wrong syntax at " << anArg << "\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Error: wrong syntax at " << anArg << "\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Error: wrong syntax at " << anArg << "\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
- // currently HLRDeviationAngle is used instead of DeviationAngle in most places
- aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
+ aDefParams->SetDeviationAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
}
else if (anArg == "-AUTOTR"
|| anArg == "-AUTOTRIANG"
if (anArgIter >= theArgsNb
|| !ViewerTest::ParseOnOff (theArgVec[anArgIter], toTurnOn))
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
aDefParams->SetAutoTriangulation (toTurnOn);
}
else
{
- std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << anArg << "'";
return 1;
}
}
if (aView.IsNull()
|| aViewer.IsNull())
{
- std::cerr << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLight->Attenuation (anAtten[0], anAtten[1]);
theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
+ theDi << " Range: " << aLight->Range() << "\n";
break;
}
case V3d_SPOT:
theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
theDi << " Angle: " << (aLight->Angle() * 180.0 / M_PI) << "\n";
theDi << " Exponent: " << aLight->Concentration() << "\n";
+ theDi << " Range: " << aLight->Range() << "\n";
break;
}
default:
{
if (++anArgIt >= theArgsNb)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (++anArgIt >= theArgsNb)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (aLightOld.IsNull())
{
- std::cerr << "Light " << theArgVec[anArgIt] << " is undefined!\n";
+ Message::SendFail() << "Error: Light " << theArgVec[anArgIt] << " is undefined";
return 1;
}
}
Handle(V3d_Light) aLightDel;
if (++anArgIt >= theArgsNb)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (++anArgIt >= theArgsNb
|| aLightCurr.IsNull())
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_DIRECTIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (++anArgIt >= theArgsNb
|| aLightCurr.IsNull())
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (++anArgIt >= theArgsNb
|| aLightCurr.IsNull())
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| aLightCurr.IsNull()
|| aLightCurr->Type() != Graphic3d_TOLS_SPOT)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| aLightCurr.IsNull()
|| aLightCurr->Type() != Graphic3d_TOLS_SPOT)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aLightCurr->SetConcentration ((Standard_ShortReal )Atof (theArgVec[anArgIt]));
}
+ else if (anArgCase.IsEqual("RANGE")
+ || anArgCase.IsEqual("-RANGE"))
+ {
+ if (++anArgIt >= theArgsNb
+ || aLightCurr.IsNull()
+ || aLightCurr->Type() == Graphic3d_TOLS_AMBIENT
+ || aLightCurr->Type() == Graphic3d_TOLS_DIRECTIONAL)
+ {
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
+ return 1;
+ }
+
+ aLightCurr->SetRange ((Standard_ShortReal)Atof (theArgVec[anArgIt]));
+ }
else if (anArgCase.IsEqual ("HEAD")
|| anArgCase.IsEqual ("HEADLIGHT")
|| anArgCase.IsEqual ("-HEAD")
if (aLightCurr.IsNull()
|| aLightCurr->Type() == Graphic3d_TOLS_AMBIENT)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Warning: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Warning: unknown argument '" << anArg << "'";
}
}
{
if (theArgsNb > 2)
{
- std::cerr << "Error: 'vpbrenv' command has only one argument\n";
+ Message::SendFail ("Syntax error: 'vpbrenv' command has only one argument");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cerr << "Error: unknown argument [" << theArgVec[1] << "] for 'vpbrenv' command\n";
+ Message::SendFail() << "Syntax error: unknown argument [" << theArgVec[1] << "] for 'vpbrenv' command";
return 1;
}
|| aVal == "triangles") aFlag = Graphic3d_RenderingParams::PerfCounters_Triangles;
else if (aVal == "pnts"
|| aVal == "points") aFlag = Graphic3d_RenderingParams::PerfCounters_Points;
+ else if (aVal == "lines") aFlag = Graphic3d_RenderingParams::PerfCounters_Lines;
else if (aVal == "mem"
|| aVal == "gpumem"
|| aVal == "estimmem") aFlag = Graphic3d_RenderingParams::PerfCounters_EstimMem;
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Error: unknown argument '" << theArgVec[1] << "'\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << theArgVec[1] << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
}
{
theDI << " tris";
}
+ if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Lines) != 0)
+ {
+ theDI << " lines";
+ }
if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Points) != 0)
{
theDI << " pnts";
}
else
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aNbSamples = Draw::Atoi (theArgVec[anArgIter]);
if (aNbSamples < 0)
{
- std::cerr << "Error: invalid number of MSAA samples " << aNbSamples << ".\n";
+ Message::SendFail() << "Syntax error: invalid number of MSAA samples " << aNbSamples << "";
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_ShortReal aFeather = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
if (aFeather <= 0.0f)
{
- std::cerr << "Error: invalid value of line width feather " << aFeather << ". Should be > 0\n";
+ Message::SendFail() << "Syntax error: invalid value of line width feather " << aFeather << ". Should be > 0";
return 1;
}
aParams.LineFeather = aFeather;
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_ShortReal aWeight = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
if (aWeight < 0.f || aWeight > 1.f)
{
- std::cerr << "Error: invalid value of Weighted Order-Independent Transparency depth weight factor " << aWeight << ". Should be within range [0.0; 1.0]\n";
+ Message::SendFail() << "Syntax error: invalid value of Weighted Order-Independent Transparency depth weight factor " << aWeight << ". Should be within range [0.0; 1.0]";
return 1;
}
}
else
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Real aScale = Draw::Atof (theArgVec[anArgIter]);
if (aScale < 0.01)
{
- std::cerr << "Error: invalid rendering resolution scale " << aScale << ".\n";
+ Message::SendFail() << "Syntax error: invalid rendering resolution scale " << aScale << "";
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
// We allow RaytracingDepth be more than 10 in case of GI enabled
if (aDepth < 1 || (aDepth > 10 && !aParams.IsGlobalIlluminationEnabled))
{
- std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
+ Message::SendFail() << "Syntax error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]";
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString aMaxRadStr = theArgVec[anArgIter];
if (!aMaxRadStr.IsRealValue())
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Real aMaxRadiance = aMaxRadStr.RealValue();
if (aMaxRadiance <= 0.0)
{
- std::cerr << "Error: invalid radiance clamping value " << aMaxRadiance << ".\n";
+ Message::SendFail() << "Syntax error: invalid radiance clamping value " << aMaxRadiance;
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aTileSize = Draw::Atoi (theArgVec[anArgIter]);
if (aTileSize < 1)
{
- std::cerr << "Error: invalid size of ISS tile " << aTileSize << ".\n";
+ Message::SendFail() << "Syntax error: invalid size of ISS tile " << aTileSize;
return 1;
}
aParams.RayTracingTileSize = aTileSize;
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aNbTiles = Draw::Atoi (theArgVec[anArgIter]);
if (aNbTiles < -1)
{
- std::cerr << "Error: invalid number of ISS tiles " << aNbTiles << ".\n";
+ Message::SendFail() << "Syntax error: invalid number of ISS tiles " << aNbTiles;
return 1;
}
else if (aNbTiles > 0
&& (aNbTiles < 64
|| aNbTiles > 1024))
{
- std::cerr << "Warning: suboptimal number of ISS tiles " << aNbTiles << ". Recommended range: [64, 1024].\n";
+ Message::SendWarning() << "Warning: suboptimal number of ISS tiles " << aNbTiles << ". Recommended range: [64, 1024].";
}
aParams.NbRayTracingTiles = aNbTiles;
}
}
aParams.UseEnvironmentMapBackground = toEnable;
}
+ else if (aFlag == "-ignorenormalmap")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.ToIgnoreNormalMapInRayTracing ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.ToIgnoreNormalMapInRayTracing = toEnable;
+ }
else if (aFlag == "-twoside")
{
if (toPrint)
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
}
Graphic3d_TypeOfShadingModel aModel = Graphic3d_TOSM_DEFAULT;
}
else
{
- std::cout << "Error: unknown shading model '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error: unknown shading model '" << theArgVec[anArgIter] << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvPow2Size = Draw::Atoi (theArgVec[anArgIter]);
if (aPbrEnvPow2Size < 1)
{
- std::cout << "Error: 'Pow2Size' of PBR Environment has to be greater or equal 1\n";
+ Message::SendFail ("Syntax error: 'Pow2Size' of PBR Environment has to be greater or equal 1");
return 1;
}
aParams.PbrEnvPow2Size = aPbrEnvPow2Size;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvSpecMapNbLevels = Draw::Atoi (theArgVec[anArgIter]);
if (aPbrEnvSpecMapNbLevels < 2)
{
- std::cout << "Error: 'SpecMapLevelsNumber' of PBR Environment has to be greater or equal 2\n";
+ Message::SendFail ("Syntax error: 'SpecMapLevelsNumber' of PBR Environment has to be greater or equal 2");
return 1;
}
aParams.PbrEnvSpecMapNbLevels = aPbrEnvSpecMapNbLevels;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvBakingDiffNbSamples = Draw::Atoi (theArgVec[anArgIter]);
if (aPbrEnvBakingDiffNbSamples < 1)
{
- std::cout << "Error: 'BakingDiffSamplesNumber' of PBR Environtment has to be greater or equal 1\n";
+ Message::SendFail ("Syntax error: 'BakingDiffSamplesNumber' of PBR Environtment has to be greater or equal 1");
return 1;
}
aParams.PbrEnvBakingDiffNbSamples = aPbrEnvBakingDiffNbSamples;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvBakingSpecNbSamples = Draw::Atoi(theArgVec[anArgIter]);
if (aPbrEnvBakingSpecNbSamples < 1)
{
- std::cout << "Error: 'BakingSpecSamplesNumber' of PBR Environtment has to be greater or equal 1\n";
+ Message::SendFail ("Syntax error: 'BakingSpecSamplesNumber' of PBR Environtment has to be greater or equal 1");
return 1;
}
aParams.PbrEnvBakingSpecNbSamples = aPbrEnvBakingSpecNbSamples;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_ShortReal aPbrEnvBakingProbability = static_cast<Standard_ShortReal>(Draw::Atof (theArgVec[anArgIter]));
if (aPbrEnvBakingProbability < 0.f
|| aPbrEnvBakingProbability > 1.f)
{
- std::cout << "Error: 'BakingProbability' of PBR Environtment has to be in range of [0, 1]\n";
+ Message::SendFail ("Syntax error: 'BakingProbability' of PBR Environtment has to be in range of [0, 1]");
return 1;
}
aParams.PbrEnvBakingProbability = aPbrEnvBakingProbability;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error: wrong syntax at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
float aFocalDist = static_cast<float> (aParam.RealValue());
if (aFocalDist < 0)
{
- std::cout << "Error: parameter can't be negative at argument '" << anArg << "'.\n";
+ Message::SendFail() << "Error: parameter can't be negative at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().CameraFocalPlaneDist = aFocalDist;
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
float aApertureSize = static_cast<float> (aParam.RealValue());
if (aApertureSize < 0)
{
- std::cout << "Error: parameter can't be negative at argument '" << anArg << "'.\n";
+ Message::SendFail() << "Error: parameter can't be negative at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().CameraApertureRadius = aApertureSize;
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
Graphic3d_RenderingParams::PerfCounters aFlags = aView->ChangeRenderingParams().CollectedStats;
if (!convertToPerfStatsFlags (aFlagsStr, aFlags))
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().CollectedStats = aFlags;
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().StatsUpdateInterval = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().StatsNbFrames = Draw::Atoi (theArgVec[anArgIter]);
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().StatsMaxChartTime = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
}
else
{
- std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error: unknown flag '" << anArg << "'";
return 1;
}
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (aFlag == "alllayers"
|| aFlag == "layers") aParam = Graphic3d_RenderingParams::PerfCounters_Layers;
else if (aFlag == "allstructs"
- || aFlag == "structs") aParam = Graphic3d_RenderingParams::PerfCounters_Structures;
+ || aFlag == "allstructures"
+ || aFlag == "structs"
+ || aFlag == "structures") aParam = Graphic3d_RenderingParams::PerfCounters_Structures;
else if (aFlag == "groups") aParam = Graphic3d_RenderingParams::PerfCounters_Groups;
else if (aFlag == "allarrays"
|| aFlag == "fillarrays"
|| aFlag == "pointarrays"
|| aFlag == "textarrays") aParam = Graphic3d_RenderingParams::PerfCounters_GroupArrays;
else if (aFlag == "triangles") aParam = Graphic3d_RenderingParams::PerfCounters_Triangles;
+ else if (aFlag == "lines") aParam = Graphic3d_RenderingParams::PerfCounters_Lines;
else if (aFlag == "points") aParam = Graphic3d_RenderingParams::PerfCounters_Points;
else if (aFlag == "geommem"
|| aFlag == "texturemem"
|| aFlag == "cpudynmax") aParam = Graphic3d_RenderingParams::PerfCounters_FrameTime;
else
{
- std::cerr << "Unknown argument '" << theArgVec[anArgIter] << "'!\n";
+ Message::SendFail() << "Error: unknown argument '" << theArgVec[anArgIter] << "'";
continue;
}
{
theDI << searchInfo (aDict, "Rendered layers") << " ";
}
- else if (aFlag == "allstructs")
+ else if (aFlag == "allstructs"
+ || aFlag == "allstructures")
{
theDI << searchInfo (aDict, "Structs") << " ";
}
- else if (aFlag == "structs")
+ else if (aFlag == "structs"
+ || aFlag == "structures")
{
- theDI << searchInfo (aDict, "Rendered structs") << " ";
+ TCollection_AsciiString aRend = searchInfo (aDict, "Rendered structs");
+ if (aRend.IsEmpty()) // all structures rendered
+ {
+ aRend = searchInfo (aDict, "Structs");
+ }
+ theDI << aRend << " ";
}
else if (aFlag == "groups")
{
if (aCurrentView.IsNull()
|| aViewer.IsNull())
{
- std::cerr << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (aName.IsEmpty())
{
- std::cerr << theArgVec[0] << " error: please specify AIS manipulator's name as the first argument.\n";
+ Message::SendFail ("Syntax error: please specify AIS manipulator's name as the first argument");
return 1;
}
{
if (!aMapAIS.IsBound2 (aName))
{
- std::cerr << theArgVec[0] << " error: could not find \"" << aName << "\" AIS object.\n";
+ Message::SendFail() << "Syntax error: could not find \"" << aName << "\" AIS object";
return 1;
}
Handle(AIS_Manipulator) aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
if (aManipulator.IsNull())
{
- std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
+ Message::SendFail() << "Syntax error: \"" << aName << "\" is not an AIS manipulator";
return 1;
}
aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
if (aManipulator.IsNull())
{
- std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
+ Message::SendFail() << "Syntax error: \"" << aName << "\" is not an AIS manipulator";
return 1;
}
}
Standard_Boolean aOnOff = aCmd.ArgBool ("part", 2);
if (aMode < 1 || aMode > 4)
{
- std::cerr << theArgVec[0] << " error: mode value should be in range [1, 4].\n";
+ Message::SendFail ("Syntax error: mode value should be in range [1, 4]");
return 1;
}
Standard_Boolean aOnOff = aCmd.ArgBool("parts", 1);
if (aMode < 1 || aMode > 4)
{
- std::cerr << theArgVec[0] << " error: mode value should be in range [1, 4].\n";
+ Message::SendFail ("Syntax error: mode value should be in range [1, 4]");
return 1;
}
Handle(AIS_InteractiveObject) anObject;
if (!aMapAIS.Find2 (anObjName, anObject))
{
- std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" does not exist.\n";
+ Message::SendFail() << "Syntax error: AIS object \"" << anObjName << "\" does not exist";
return 1;
}
&& aManip->IsAttached()
&& aManip->Object() == anObject)
{
- std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" already has manipulator.\n";
+ Message::SendFail() << "Syntax error: AIS object \"" << anObjName << "\" already has manipulator";
return 1;
}
}
ViewerTest_Names aViewNames (aViewString);
if (!ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
{
- std::cerr << theArgVec[0] << " error: wrong view name '" << aViewString << "'\n";
+ Message::SendFail() << "Syntax error: wrong view name '" << aViewString << "'";
return 1;
}
aView = ViewerTest_myViews.Find1 (aViewNames.GetViewName());
if (aView.IsNull())
{
- std::cerr << theArgVec[0] << " error: cannot find view with name '" << aViewString << "'\n";
+ Message::SendFail() << "Syntax error: cannot find view with name '" << aViewString << "'";
return 1;
}
}
const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull())
{
- std::cerr << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (theArgsNb != 2
|| !ViewerTest::ParseOnOff (theArgVec[1], toEnable))
{
- std::cout << "Syntax error: wrong number of parameters.";
+ Message::SendFail ("Syntax error: wrong number of parameters");
return 1;
}
if (toEnable != aCtx->ToHilightSelected())
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
}
else
{
- std::cout << "Syntax error: unknwon picking strategy '" << aVal << "'\n";
+ Message::SendFail() << "Syntax error: unknown picking strategy '" << aVal << "'";
return 1;
}
{
if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
{
if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
Graphic3d_ZLayerId aNewLayer = Graphic3d_ZLayerId_UNKNOWN;
if (!ViewerTest::ParseZLayer (theArgVec[anArgIter], aNewLayer))
{
- std::cerr << "Error: wrong syntax at " << theArgVec[anArgIter] << ".\n";
+ Message::SendFail() << "Syntax error at " << theArgVec[anArgIter];
return 1;
}
}
else if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
aColor);
if (aNbParsed == 0)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
anArgIter += aNbParsed;
}
else if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
{
if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
}
}
{
if (theArgsNb < 2)
{
- std::cout << "Syntax error: wrong number arguments for '" << theArgVec[0] << "'\n";
+ Message::SendFail() << "Syntax error: wrong number arguments for '" << theArgVec[0] << "'";
return 1;
}
const Handle(AIS_InteractiveContext)& aContext = ViewerTest::GetAISContext();
if (aContext.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Syntax error: wrong number parameters of flag '-depth'.\n";
+ Message::SendFail ("Syntax error: wrong number parameters of flag '-depth'");
return 1;
}
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Syntax error: wrong number parameters at '" << aParam << "'.\n";
+ Message::SendFail() << "Syntax error: wrong number parameters at '" << aParam << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error: unknown argument '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (aFile.IsEmpty())
{
- std::cout << "Syntax error: image file name is missing.\n";
+ Message::SendFail ("Syntax error: image file name is missing");
return 1;
}
Image_AlienPixMap aPixMap;
if (!aPixMap.InitZero (anImgFormat, aWidth, aHeight))
{
- std::cout << "Error: can't allocate image.\n";
+ Message::SendFail ("Error: can't allocate image");
return 1;
}
if (!aContext->MainSelector()->ToPixMap (aPixMap, aView, aType, aPickedIndex))
{
- std::cout << "Error: can't generate selection image.\n";
+ Message::SendFail ("Error: can't generate selection image");
return 1;
}
if (!aPixMap.Save (aFile))
{
- std::cout << "Error: can't save selection image.\n";
+ Message::SendFail ("Error: can't save selection image");
return 0;
}
return 0;
const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aContext.IsNull() || aView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (theNbArgs < 2)
{
- std::cout << "Syntax error: wrong number arguments\n";
+ Message::SendFail ("Syntax error: wrong number arguments");
return 1;
}
aName = theArgVec[anArgIter];
if (aName.StartsWith ("-"))
{
- std::cout << "Syntax error: object name should be specified.\n";
+ Message::SendFail ("Syntax error: object name should be specified");
return 1;
}
Handle(AIS_InteractiveObject) aPrs;
aColorRgb);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
const Standard_Real aValue = Draw::Atof (theArgVec[++anArgIter]);
if (aValue < 0.0 || aValue > 1.0)
{
- std::cout << "Syntax error: invalid transparency value " << theArgVec[anArgIter] << "\n";
+ Message::SendFail() << "Syntax error: invalid transparency value " << theArgVec[anArgIter];
return 1;
}
{
aViewCube->SetDuration (Draw::Atof (theArgVec[++anArgIter]));
}
+ else if (anArgIter + 1 < theNbArgs
+ && anArg == "-axesradius")
+ {
+ aViewCube->SetAxesRadius (Draw::Atof (theArgVec[++anArgIter]));
+ }
+ else if (anArgIter + 1 < theNbArgs
+ && anArg == "-axesconeradius")
+ {
+ aViewCube->SetAxesConeRadius (Draw::Atof (theArgVec[++anArgIter]));
+ }
+ else if (anArgIter + 1 < theNbArgs
+ && anArg == "-axessphereradius")
+ {
+ aViewCube->SetAxesSphereRadius (Draw::Atof (theArgVec[++anArgIter]));
+ }
else
{
- std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << anArg << "'";
return 1;
}
}
if (aViewCube.IsNull())
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
return 0;
}
+//===============================================================================================
+//function : VColorConvert
+//purpose :
+//===============================================================================================
+static int VColorConvert (Draw_Interpretor& theDI, Standard_Integer theNbArgs, const char** theArgVec)
+{
+ if (theNbArgs != 6)
+ {
+ std::cerr << "Error: command syntax is incorrect, see help" << std::endl;
+ return 1;
+ }
+
+ Standard_Boolean convertFrom = (! strcasecmp (theArgVec[1], "from"));
+ if (! convertFrom && strcasecmp (theArgVec[1], "to"))
+ {
+ std::cerr << "Error: first argument must be either \"to\" or \"from\"" << std::endl;
+ return 1;
+ }
+
+ const char* aTypeStr = theArgVec[2];
+ Quantity_TypeOfColor aType = Quantity_TOC_RGB;
+ if (! strcasecmp (aTypeStr, "srgb"))
+ {
+ aType = Quantity_TOC_sRGB;
+ }
+ else if (! strcasecmp (aTypeStr, "hls"))
+ {
+ aType = Quantity_TOC_HLS;
+ }
+ else if (! strcasecmp (aTypeStr, "lab"))
+ {
+ aType = Quantity_TOC_CIELab;
+ }
+ else if (! strcasecmp (aTypeStr, "lch"))
+ {
+ aType = Quantity_TOC_CIELch;
+ }
+ else
+ {
+ std::cerr << "Error: unknown colorspace type: " << aTypeStr << std::endl;
+ return 1;
+ }
+
+ double aC1 = Draw::Atof (theArgVec[3]);
+ double aC2 = Draw::Atof (theArgVec[4]);
+ double aC3 = Draw::Atof (theArgVec[5]);
+
+ Quantity_Color aColor (aC1, aC2, aC3, convertFrom ? aType : Quantity_TOC_RGB);
+ aColor.Values (aC1, aC2, aC3, convertFrom ? Quantity_TOC_RGB : aType);
+
+ // print values with 6 decimal digits
+ char buffer[1024];
+ Sprintf (buffer, "%.6f %.6f %.6f", aC1, aC2, aC3);
+ theDI << buffer;
+
+ return 0;
+}
+
+//===============================================================================================
+//function : VColorDiff
+//purpose :
+//===============================================================================================
+static int VColorDiff (Draw_Interpretor& theDI, Standard_Integer theNbArgs, const char** theArgVec)
+{
+ if (theNbArgs != 7)
+ {
+ std::cerr << "Error: command syntax is incorrect, see help" << std::endl;
+ return 1;
+ }
+
+ double aR1 = Draw::Atof (theArgVec[1]);
+ double aG1 = Draw::Atof (theArgVec[2]);
+ double aB1 = Draw::Atof (theArgVec[3]);
+ double aR2 = Draw::Atof (theArgVec[4]);
+ double aG2 = Draw::Atof (theArgVec[5]);
+ double aB2 = Draw::Atof (theArgVec[6]);
+
+ Quantity_Color aColor1 (aR1, aG1, aB1, Quantity_TOC_RGB);
+ Quantity_Color aColor2 (aR2, aG2, aB2, Quantity_TOC_RGB);
+
+ theDI << aColor1.DeltaE2000 (aColor2);
+
+ return 0;
+}
+
//=======================================================================
//function : ViewerCommands
//purpose :
"\n\t\t: [-labels Label1 Label2 ...] [-label Index Label]"
"\n\t\t: [-freeLabels NbOfLabels Label1 Label2 ...]"
"\n\t\t: [-xy Left=0 Bottom=0]"
+ "\n\t\t: [-uniform lightness hue_from hue_to]"
"\n\t\t: -demo - displays a color scale with demonstratio values"
"\n\t\t: -colors - set colors for all intervals"
"\n\t\t: -color - set color for specific interval"
+ "\n\t\t: -uniform - generate colors with the same lightness"
"\n\t\t: -textpos - horizontal label position relative to color scale bar"
"\n\t\t: -labelAtBorder - vertical label position relative to color interval;"
"\n\t\t: at border means the value inbetween neighbor intervals,"
"\n\t\t: -title - set title"
"\n\t\t: -reversed - setup smooth color transition between intervals"
"\n\t\t: -smoothTransition - swap colorscale direction"
- "\n\t\t: -hueRange - set hue angles corresponding to minimum and maximum values"
+ "\n\t\t: -hueRange - set hue angles corresponding to minimum and maximum values",
__FILE__, VColorScale, group);
theCommands.Add("vgraduatedtrihedron",
"vgraduatedtrihedron : -on/-off [-xname Name] [-yname Name] [-zname Name] [-arrowlength Value]\n"
"- 1) single click selection\n"
"- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
"- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
- "- 4) -allowoverlap manages overlap and inclusion detection in rectangular selection.\n"
- " If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined rectangle will be detected,\n"
- " otherwise algorithm will chose only fully included sensitives. Default behavior is to detect only full inclusion. "
- " (partial inclusion - overlap - is not allowed by default)\n"
+ "- 4) -allowoverlap manages overlap and inclusion detection in rectangular and polygonal selection.\n"
+ " If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined \n"
+ " rectangle or polygon will be detected, otherwise algorithm will chose only fully included sensitives.\n"
+ " Default behavior is to detect only full inclusion. (partial inclusion - overlap - is not allowed by default)\n"
"- 5) any of these selections with shift button pressed",
__FILE__, VSelect, group);
theCommands.Add ("vmoveto",
"\n -{linearAtten}uation value"
"\n -angle angleDeg"
"\n -{spotexp}onent value"
+ "\n -range value"
"\n -local|-global"
"\n\n example: vlight -add positional -head 1 -pos 0 1 1 -color red"
"\n example: vlight -change 0 -direction 0 -1 0 -linearAttenuation 0.2",
"\n '-gi on|off' Enables/disables global illumination effects"
"\n '-brng on|off' Enables/disables blocked RNG (fast coherent PT)"
"\n '-env on|off' Enables/disables environment map background"
+ "\n '-ignoreNormalMap on|off' Enables/disables normal map ignoring during path tracing"
"\n '-twoside on|off' Enables/disables two-sided BSDF models (PT mode)"
"\n '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
"\n '-issd on|off' Shows screen sampling distribution in ISS mode"
"\n '-exposure value' Exposure value for tone mapping (0.0 value disables the effect)"
"\n '-whitepoint value' White point value for filmic tone mapping"
"\n '-tonemapping mode' Tone mapping mode (disabled, filmic)"
- "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triagles|points"
+ "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triangles|points"
"\n ' |gpuMem|frameTime|basic|extended|full|nofps|skipImmediate'"
"\n Show/hide performance counters (flags can be combined)"
"\n '-perfUpdateInterval nbSeconds' Performance counters update interval"
theCommands.Add("vstatprofiler",
"\n vstatprofiler [fps|cpu|allLayers|layers|allstructures|structures|groups"
"\n |allArrays|fillArrays|lineArrays|pointArrays|textArrays"
- "\n |triagles|points|geomMem|textureMem|frameMem"
+ "\n |triangles|points|geomMem|textureMem|frameMem"
"\n |elapsedFrame|cpuFrameAverage|cpuPickingAverage|cpuCullingAverage|cpuDynAverage"
"\n |cpuFrameMax|cpuPickingMax|cpuCullingMax|cpuDynMax]"
"\n [-noredraw]"
"\n\t\t: -boxCornerMinSize Value minimal box corner size"
"\n\t\t: -axesPadding Value padding between box and arrows"
"\n\t\t: -roundRadius Value relative radius of corners of sides within [0.0, 0.5] range"
+ "\n\t\t: -axesRadius Value radius of axes of the trihedron"
+ "\n\t\t: -axesConeRadius Value radius of the cone (arrow) of the trihedron"
+ "\n\t\t: -axesSphereRadius Value radius of the sphere (central point) of trihedron"
"\n\t\t: -fixedanimation {0|1} uninterruptible animation loop"
"\n\t\t: -duration Seconds animation duration in seconds",
__FILE__, VViewCube, group);
+ theCommands.Add("vcolorconvert" ,
+ "vcolorconvert {from|to} type C1 C2 C2"
+ "\n\t\t: vcolorconvert from type C1 C2 C2: Converts color from specified color space to linear RGB"
+ "\n\t\t: vcolorconvert to type R G B: Converts linear RGB color to specified color space"
+ "\n\t\t: type can be sRGB, HLS, Lab, or Lch",
+ __FILE__,VColorConvert,group);
+ theCommands.Add("vcolordiff" ,
+ "vcolordiff R1 G1 B1 R2 G2 B2: returns CIEDE2000 color difference between two RGB colors",
+ __FILE__,VColorDiff,group);
}
projects / occt.git / blobdiff