DisplayVersionCommand::DisplayVersionCommand()
{
osVersion = "0.001.001 BETA";
setAlias("ver");
setHelp("This command shows the current version of the running operating system.");
setDesc("Shows the current operating system version number");
}
DirectoryIterator::DirectoryIterator()
: mIter(mFileList)
{
setName("DirectoryIterator");
setDesc(QObject::tr("Iterates through a directory and outputs all files that fit the filter"));
setGroup("input");
mNameOut.setName("fileName");
mNameOut.setDesc(QObject::tr("The file name only, without the path"));
addOutputPort(mNameOut);
mOut.setName("filePath");
mOut.setDesc(QObject::tr("The full file path"));
addOutputPort(mOut);
mFilter.setName("nameFilter");
mFilter.setMode(OptionalPortMode);
mFilter.setDesc(QObject::tr("File extension filter, separated by space. example: *.png *.jpg *.xpm"));
addInputPort(mFilter);
mIn.setName("dir");
mIn.setDesc(QObject::tr("Directory to iterate"));
addInputPort(mIn);
mRepeat.setName("repeat");
mRepeat.setDefault(false);
mRepeat.setDesc(QObject::tr("Repeat from beginning of the list if finished"));
mRepeat.setIcon(QImage(":/SimpleNodes/repeat.png"));
addInputPort(mRepeat);
}
void LLParcel::clearParcel()
{
overrideParcelFlags(PF_DEFAULT);
setName(LLStringUtil::null);
setDesc(LLStringUtil::null);
setMediaURL(LLStringUtil::null);
setMediaType(LLStringUtil::null);
setMediaID(LLUUID::null);
setMediaDesc(LLStringUtil::null);
setMediaAutoScale(0);
setMediaLoop(TRUE);
mMediaWidth = 0;
mMediaHeight = 0;
setMediaCurrentURL(LLStringUtil::null);
setMediaAllowNavigate(TRUE);
setMediaPreventCameraZoom(FALSE);
setMediaURLTimeout(0.0f);
setMusicURL(LLStringUtil::null);
setInEscrow(FALSE);
setAuthorizedBuyerID(LLUUID::null);
setCategory(C_NONE);
setSnapshotID(LLUUID::null);
setUserLocation(LLVector3::zero);
setUserLookAt(LLVector3::x_axis);
setLandingType(L_LANDING_POINT);
setAuctionID(0);
setGroupID(LLUUID::null);
setPassPrice(0);
setPassHours(0.f);
mAccessList.clear();
mBanList.clear();
//mRenterList.reset();
}
Threshold::Threshold()
{
setName("Threshold");
setDesc(QObject::tr("Thresholds an image"));
setGroup("image/color");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
mThreshold.setName("threshold");
mThreshold.setDesc(QObject::tr("Threshold value"));
mThreshold.setDefault(128);
mThreshold.setRange(0, 255);
addInputPort(mThreshold);
mMode.setName("mode");
mMode.setDesc(QObject::tr("Thresholding mode"));
mMode.addChoice(cv::THRESH_BINARY, tr("Binary (value = value > threshold ? max_value : 0 )"));
mMode.addChoice(cv::THRESH_BINARY_INV, tr("Binary inverted (value = value > threshold ? 0 : max_value)"));
mMode.addChoice(cv::THRESH_TOZERO, tr("To zero (value = value > threshold ? value : 0)"));
mMode.addChoice(cv::THRESH_TOZERO_INV, tr("To zero inverted (value = value > threshold ? 0 : value)"));
mMode.addChoice(cv::THRESH_TRUNC, tr("Truncate (value = value > threshold ? threshold : value)"));
mMode.addChoice(cv::THRESH_OTSU, tr("Otsu’s Algorithm (threshold automatically determined)"));
mMode.addChoice(cv::THRESH_OTSU+1, tr("Otsu’s Algorithm inverted (threshold automatically determined)"));
mMode.addChoice(cv::THRESH_TRIANGLE, tr("Triangle algorithm (threshold automatically determined)"));
mMode.addChoice(cv::THRESH_TRIANGLE+1, tr("Triangle algorithm inverted (threshold automatically determined)"));
mMode.setDefault(cv::THRESH_BINARY);
addInputPort(mMode);
}
BrighnessContrast::BrighnessContrast()
{
setName("BrightnessContrast");
setDesc(QObject::tr("Adjusts brightness and contrast"));
setGroup("image/color");
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mBrighness.setName("brightnessFactor");
mBrighness.setDesc(QObject::tr("Adjust the brightness"));
mBrighness.setDefault(0);
mBrighness.setRange(-100, 100);
addInputPort(mBrighness);
mContrast.setName("contrastFactor");
mContrast.setDesc(QObject::tr("Adjust the contrast"));
mContrast.setDefault(0);
mContrast.setRange(-100, 100);
addInputPort(mContrast);
}
xpr_bool_t ShortcutDlg::OnInitDialog(void)
{
super::OnInitDialog();
CComboBox *sComboBox;
sComboBox = (CComboBox *)GetDlgItem(IDC_CREATE_SHORTCUT_SHOWCMD);
sComboBox->AddString(gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.show.default")));
sComboBox->AddString(gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.show.minimize")));
sComboBox->AddString(gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.show.maximize")));
((CEdit *)GetDlgItem(IDC_CREATE_SHORTCUT_NAME ))->LimitText(XPR_MAX_PATH);
((CEdit *)GetDlgItem(IDC_CREATE_SHORTCUT_TARGET ))->LimitText(XPR_MAX_PATH);
((CEdit *)GetDlgItem(IDC_CREATE_SHORTCUT_STARTUP))->LimitText(XPR_MAX_PATH);
((CEdit *)GetDlgItem(IDC_CREATE_SHORTCUT_DESC ))->LimitText(MAX_SHORTCUT_DESC);
setDesc(gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.top_desc")));
setDescIcon(IDI_SHORTCUT, XPR_TRUE);
WORD sInvalidComb = HKCOMB_A | HKCOMB_C | HKCOMB_NONE | HKCOMB_S | HKCOMB_SA | HKCOMB_SC | HKCOMB_SCA;
((CHotKeyCtrl *)GetDlgItem(IDC_CREATE_SHORTCUT_HOTKEY))->SetRules(sInvalidComb, HOTKEYF_CONTROL | HOTKEYF_ALT);
SetWindowText(gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.title")));
SetDlgItemText(IDC_CREATE_SHORTCUT_LABEL_NAME, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.name")));
SetDlgItemText(IDC_CREATE_SHORTCUT_LABEL_TARGET, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.target")));
SetDlgItemText(IDC_CREATE_SHORTCUT_TARGET_BROWSE, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.button.target_browse")));
SetDlgItemText(IDC_CREATE_SHORTCUT_GROUP_ADVANCED, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.group.advanced")));
SetDlgItemText(IDC_CREATE_SHORTCUT_LABEL_STARTUP, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.startup")));
SetDlgItemText(IDC_CREATE_SHORTCUT_LABEL_HOTKEY, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.hotkey")));
SetDlgItemText(IDC_CREATE_SHORTCUT_LABEL_SHOWCMD, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.show")));
SetDlgItemText(IDC_CREATE_SHORTCUT_LABEL_DESC, gApp.loadString(XPR_STRING_LITERAL("popup.create_shortcut.label.desc")));
return XPR_TRUE;
}
DisplayHelpCommand::DisplayHelpCommand(std::vector<Command*>* cmdList)
{
setAlias("help");
setDesc("Displays help information about system or command");
setHelp("Follow this command with the name of another command to get more information \n about that command.");
setCommandList(cmdList);
}
void Stat::setAll(const char* allch) {
String all = allch;
int indexof = all.find(",");
if (indexof > -1) {
setDesc(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setDisplay(all.substr(0,indexof++).c_str());
all=all.substr(indexof);
indexof = all.find(",");
setIVal(all.substr(0,indexof++).c_str());
} else {
setDesc("");
setDisplay("");
setIVal("");
}
}
void LLParcel::unpackMessage(LLMessageSystem* msg)
{
std::string buffer;
msg->getU32Fast( _PREHASH_ParcelData,_PREHASH_ParcelFlags, mParcelFlags );
msg->getS32Fast( _PREHASH_ParcelData,_PREHASH_SalePrice, mSalePrice );
msg->getStringFast( _PREHASH_ParcelData,_PREHASH_Name, buffer );
setName(buffer);
msg->getStringFast( _PREHASH_ParcelData,_PREHASH_Desc, buffer );
setDesc(buffer);
msg->getStringFast( _PREHASH_ParcelData,_PREHASH_MusicURL, buffer );
setMusicURL(buffer);
msg->getStringFast( _PREHASH_ParcelData,_PREHASH_MediaURL, buffer );
setMediaURL(buffer);
// non-optimized version
msg->getU8 ( "ParcelData", "MediaAutoScale", mMediaAutoScale );
msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_MediaID, mMediaID );
msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_GroupID, mGroupID );
msg->getS32Fast( _PREHASH_ParcelData,_PREHASH_PassPrice, mPassPrice );
msg->getF32Fast( _PREHASH_ParcelData,_PREHASH_PassHours, mPassHours );
U8 category;
msg->getU8Fast( _PREHASH_ParcelData,_PREHASH_Category, category);
mCategory = (ECategory)category;
msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_AuthBuyerID, mAuthBuyerID);
msg->getUUIDFast( _PREHASH_ParcelData,_PREHASH_SnapshotID, mSnapshotID);
msg->getVector3Fast(_PREHASH_ParcelData,_PREHASH_UserLocation, mUserLocation);
msg->getVector3Fast(_PREHASH_ParcelData,_PREHASH_UserLookAt, mUserLookAt);
U8 landing_type;
msg->getU8Fast( _PREHASH_ParcelData,_PREHASH_LandingType, landing_type);
mLandingType = (ELandingType)landing_type;
// New Media Data
// Note: the message has been converted to TCP
if(msg->has("MediaData"))
{
msg->getString("MediaData", "MediaDesc", buffer);
setMediaDesc(buffer);
msg->getString("MediaData", "MediaType", buffer);
setMediaType(buffer);
msg->getS32("MediaData", "MediaWidth", mMediaWidth);
msg->getS32("MediaData", "MediaHeight", mMediaHeight);
msg->getU8 ( "MediaData", "MediaLoop", mMediaLoop );
msg->getU8 ( "MediaData", "ObscureMedia", mObscureMedia );
msg->getU8 ( "MediaData", "ObscureMusic", mObscureMusic );
}
else
{
setMediaType(std::string("video/vnd.secondlife.qt.legacy"));
setMediaDesc(std::string("No Description available without Server Upgrade"));
mMediaLoop = true;
mObscureMedia = true;
mObscureMusic = true;
}
}
CustomFilter::CustomFilter()
{
setName("Tutorial Camera");
setDesc(QObject::tr("A virtual camera for the tutorial robot"));
setGroup("tutorial");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("The image of the robot scene"));
addOutputPort(mOut);
}
MultipleTemplateMatching::MultipleTemplateMatching()
{
setName("MultipleTemplateMatching");
setDesc(QObject::tr("Match a template on an image and output the all found positions, the matching scores and the result image"));
setGroup("image/object detection");
mImageIn.setName("image");
addInputPort(mImageIn);
mTemplateIn.setName("template");
addInputPort(mTemplateIn);
mMethodIn.setName("method");
mMethodIn.addChoice(CV_TM_CCORR_NORMED,tr("normalized cross correlation"));
mMethodIn.addChoice(CV_TM_CCOEFF_NORMED, tr("fast normalized cross correlation"));
mMethodIn.addChoice(CV_TM_SQDIFF_NORMED, tr("normalized squared differences"));
mMethodIn.setDefault(CV_TM_CCOEFF_NORMED);
mMethodIn.setVisibility(AdvancedPortVisibility);
addInputPort(mMethodIn);
mMinScoreIn.setName("min score");
mMinScoreIn.setRange(0.0,1.0);
mMinScoreIn.setDefault(0.0);
addInputPort(mMinScoreIn);
mOffsetIn.setName("offset");
mOffsetIn.setDesc(QObject::tr("Offset that will be added to all calculated positions"));
mOffsetIn.setDefault(QPointF(0.0, 0.0));
addInputPort(mOffsetIn);
mOffsetIn.setVisibility(AdvancedPortVisibility);
mScoreOuts.setName("scores");
mScoreOuts.setDesc(QObject::tr("The matching score of the found position"));
addOutputListPort(mScoreOuts);
mPositionOuts.setName("positions");
addOutputListPort(mPositionOuts);
mNeedNewImage.setName("fresh image only");
mNeedNewImage.setDesc(QObject::tr("Only execute if the main input has a new image"));
mNeedNewImage.setDefault(true);
mNeedNewImage.setVisibility(AdvancedPortVisibility);
addInputPort(mNeedNewImage);
mSendResultImage.setName("send result image");
mSendResultImage.setDesc(QObject::tr("Set this to true if the result image of the template matching should be send on the port <result>"));
mSendResultImage.setDefault(false);
mSendResultImage.setVisibility(ExpertPortVisibility);
addInputPort(mSendResultImage);
mResultOut.setName("result");
mResultOut.setDesc(QObject::tr("The result image from the template matching operation. Only sent if the port <send result image> is set to true"));
mResultOut.setVisibility(ExpertPortVisibility);
addOutputPort(mResultOut);
}
Delay::Delay()
{
setName("Delay");
setGroup("helper");
setDesc(QObject::tr("Insert a specific delay into your image processing chain"));
mDelay.setName("delayTime");
mDelay.setDesc(QObject::tr("Delay time in ms"));
mDelay.setRange(1,10000);
mDelay.setDefault(1000);
addInputPort(mDelay);
}
MomentFilter::MomentFilter()
{
setName("Moments");
setDesc(QObject::tr("Calculates the moments of a contour."));
setGroup("image/contour");
mIn.setName("input");
mNumPixelsOut.setName("numPixels");
mNumPixelsOut.setDesc(QObject::tr("The number of pixels inside a contour(m00)"));
mCogOut.setName("cog");
mCogOut.setDesc(QObject::tr("The center of gravity (based on m01, m10 and m00"));
addInputListPort(mIn);
addOutputListPort(mNumPixelsOut);
addOutputListPort(mCogOut);
}
SimpleCameraInput::SimpleCameraInput()
{
setName("Webcam");
setDesc(QObject::tr("Reads a the default webcam with the default setup"));
setGroup("input");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mFps.setName("fps");
mFps.setDesc(QObject::tr("Camera fps. Must be connected to a minimum fps core to avoid sending the same image multiple times"));
addOutputPort(mFps);
}
ConvexHull::ConvexHull()
{
setName("ConvexHull");
setDesc(QObject::tr("Calculates the convex hull of contour"));
setGroup("image/contour");
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputListPort(mIn);
mOut.setName("convexHull");
mOut.setDesc(QObject::tr("Convex hull of input image"));
addOutputListPort(mOut);
}
ConvexHullFilter::ConvexHullFilter()
{
setName("ConvexHullFilter");
setDesc("Calculates the convex hull of contour");
setGroup("user");
mIn.setName("input");
mIn.setDesc("A list of outer contours or a single one");
addInputListPort(mIn);
mOut.setName("convexHull");
mOut.setDesc("The convex hulls in the same order as the inputs");
addOutputListPort(mOut);
}
DepthMap2Image::DepthMap2Image()
{
setName("DepthMap2Image");
setDesc(QObject::tr("Creates a grayscale image from the DepthMap"));
setGroup("depth map");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
}
DepthMapWriter::DepthMapWriter()
{
setName("DepthMapWriter");
setDesc(QObject::tr("Inverts the image"));
setGroup("depth map");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
}
SobelFilter::SobelFilter()
{
setName("Sobel");
setDesc(QObject::tr("Applies a sobel filter to an image"));
setGroup("image/edge detection");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
}
FlipImage::FlipImage()
{
setName("Flip");
setDesc(QObject::tr("Flips an image horizontal, vertical or both"));
setGroup("image/reshape");
addInputPort(mImageIn);
addOutputPort(mImageOut);
mFlipModeIn.setName("flipMode");
mFlipModeIn.addChoice(0, tr("Vertical"));
mFlipModeIn.addChoice(1, tr("Horizontal"));
mFlipModeIn.addChoice(-1, tr("Both"));
mFlipModeIn.setDefault(0);
addInputPort(mFlipModeIn);
}
ContourWriter::ContourWriter()
{
setName("ContourWriter");
setDesc(QObject::tr("Writes a extracted contour to disc"));
setGroup("image/contour");
mFile.setName("fileName");
mOffsetIn.setName("offset");
mOffsetIn.setDesc(QObject::tr("Offset that will be added to all calculated positions"));
mOffsetIn.setDefault(QPointF(0.0, 0.0));
mContour.setName("contour");
mContour.setDesc(QObject::tr("A list of the calculated outer contours"));
addInputPort(mFile);
addInputPort(mOffsetIn);
addInputListPort(mContour);
}
int SafetWorkflow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = SafetXmlObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
*reinterpret_cast< QString*>(_v) = id();
break;
case 1:
*reinterpret_cast< QString*>(_v) = desc();
break;
}
_id -= 2;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
setId(*reinterpret_cast< QString*>(_v));
break;
case 1:
setDesc(*reinterpret_cast< QString*>(_v));
break;
}
_id -= 2;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 2;
}
#endif // QT_NO_PROPERTIES
return _id;
}
PoseInput::PoseInput()
{
setName(tr("Pose"));
setDesc(QObject::tr("Pose input filter for the automation"));
setGroup("automation/input");
mIn.setName("input pose");
mIn.setMode(SingleShotPortMode);
mOut.setName("output pose");
mUpdated.setName("updated");
mUpdated.setVisibility(ExpertPortVisibility);
addInputPort(mIn);
addOutputPort(mOut);
addOutputPort(mUpdated);
}
FindContours::FindContours()
{
setName("FindContours");
setDesc(QObject::tr("Extracts contours from an image"));
setGroup("image/contour");
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
mOffsetIn.setName("offset");
mOffsetIn.setDesc(QObject::tr("Offset that will be added to all calculated positions"));
mOffsetIn.setDefault(QPointF(0.0, 0.0));
addInputPort(mOffsetIn);
mContourOut.setName("contour");
addOutputListPort(mContourOut);
}
ContoursFilter::ContoursFilter()
{
setName("ContoursFilter");
setDesc("Extracts contours from an image. The image should be thresholded");
setGroup("user");
mIn.setName("input");
mIn.setDesc("Thresholded input image");
addInputPort(mIn);
mOffsetIn.setName("offset");
mOffsetIn.setDesc("Offset that will be added to all calculated positions");
mOffsetIn.setDefault(QPointF(0.0, 0.0));
addInputPort(mOffsetIn);
mContourOut.setName("contour");
mContourOut.setDesc("A list of the calculated outer contours");
addOutputListPort(mContourOut);
}
VarianceFilter::VarianceFilter()
{
setName("VarianceFilter");
setDesc("Calculates the variance inside the image or region of interest");
setGroup("user");
mIn.setName("imageIn");
addInputPort(mIn);
mRoiIn.setMode(OptionalPortMode);
mRoiIn.setName("roi");
addInputPort(mRoiIn);
mVarianceOut.setName("variance");
addOutputPort(mVarianceOut);
mMeanOut.setName("mean grayscale");
addOutputPort(mMeanOut);
}
ScaleImage::ScaleImage()
{
setName("Scale");
setDesc(QObject::tr("Scales an image by a factor"));
setGroup("image/reshape");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
mScale.setName("scale");
mScale.setDesc(QObject::tr("The new image size in percent of the original image"));
mScale.setRange(10, 1000);
mScale.setDefault(100.0);
addInputPort(mScale);
}
ImageInput::ImageInput()
{
setName("ImageInput");
setDesc(QObject::tr("Reads a single image from disc and outputs it"));
setGroup("input");
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("fileName");
mIn.setDesc(QObject::tr("File to read"));
mIn.setFilter("*.jpg *.png *.bmp");
mAlwaysRead.setName("alwaysReload");
mAlwaysRead.setDefault(false);
mAlwaysRead.setDesc(QObject::tr("Read the file from disc every time"));
mAlwaysRead.setVisibility(AdvancedPortVisibility);
addInputPort(mIn);
addInputPort(mAlwaysRead);
}
FetchTemplate::FetchTemplate()
{
setName("FetchTemplate");
setDesc(QObject::tr("Fetches a template from the given image on the ROI position"));
setGroup("image/object detection");
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
mOut.setName("template");
mOut.setDesc(QObject::tr("Template output port"));
addOutputPort(mOut);
mRoi.setName("roi");
mRoi.setDesc(QObject::tr("Region where the template is extracted. Only applied when changed"));
mRoi.setMode(SingleShotPortMode);
mRoi.setDisplayVisibility(false);
addInputPort(mRoi);
}
RotateImage::RotateImage()
{
setName("Rotate");
setGroup("image/reshape");
setDesc(QObject::tr("Rotates an image"));
mOut.setName("imageOut");
mOut.setDesc(QObject::tr("Image output"));
addOutputPort(mOut);
mIn.setName("imageIn");
mIn.setDesc(QObject::tr("Image input"));
addInputPort(mIn);
mAngle.setName("angle");
mAngle.setDesc(QObject::tr("Angle of the rotation"));
mAngle.addChoice(0, tr("None"));
mAngle.addChoice(90, tr("90 degree clockwise"));
mAngle.addChoice(180, tr("180 degree"));
mAngle.addChoice(270, tr("90 degree counter-clockwise"));
mAngle.setDefault(0);
addInputPort(mAngle);
}