void Composite::Visit(void* instance, Visitor& visitor) const
{
if (!instance)
{
return;
}
DynArray< Field >::ConstIterator itr = m_Fields.Begin();
DynArray< Field >::ConstIterator end = m_Fields.End();
for ( ; itr != end; ++itr )
{
const Field* field = &*itr;
if ( !visitor.VisitField( instance, field ) )
{
continue;
}
DataPtr data = field->CreateData();
data->ConnectField( instance, field );
data->Accept( visitor );
data->Disconnect();
}
}
std::vector<Vector3D> CustomMetric::getPointCloud() const
{
std::vector<Vector3D> retval;
DataPtr model = this->getModel();
std::vector<Transform3D> pos = this->calculateOrientations();
std::vector<Vector3D> cloud;
Transform3D rrMd;
if (model)
{
rrMd = model->get_rMd();
cloud = model->getPointCloud();
}
else
{
cloud.push_back(Vector3D::Zero());
rrMd = Transform3D::Identity();
}
for (unsigned i=0; i<pos.size(); ++i)
{
Transform3D rMd = pos[i] * rrMd;
for (unsigned j=0; j<cloud.size(); ++j)
{
Vector3D p_r = rMd.coord(cloud[j]);
retval.push_back(p_r);
}
}
return retval;
}
void testData()
{
DataPtr dun = Data::create("hello-worldhello-worldhello-worldhello-worldhello-worldhello-worldhello-worldhello-worldhello-worldhello-worldhello-worldhello-world");
log(dun->toString());
DataPtr d = ZLib::compress(dun);
DataPtr base64 = Base64::encode(d);
if(base64)
{
log(base64->toString());
DataPtr dec = Base64::decode(base64);
log(ZLib::decompress(dec)->toString());
std::string dec_string = base64->toString();
if(dec)
log(dec_string);
dec_string[2] = '*';
DataPtr dec2 = Base64::decode(Data::create(dec_string));
if(dec2)
log("Dec ok");
else
log("Dec failed");
}
}
void testEncryption()
{
std::string plain_text = "The rooster crows at midnight!";
std::string key = "A16ByteKey......";
DataPtr iv = Data::create("IV6ByteKey......");
Data::ByteArr& iv_raw = iv->getRawData();
//iv_raw.resize(Protect::IV_SIZE, 0);
DataPtr enc = Protect::encodeIV(Data::create(plain_text),
Data::create(key),
iv);
DataPtr enc2 = Protect::encode(Data::create(plain_text),
Data::create(key));
log("Enc: "+Base64::encode(enc)->toString());
log("Enc2: "+Base64::encode(enc2)->toString());
DataPtr dec = Protect::decodeIV(enc, Data::create(key), iv);
DataPtr dec2 = Protect::decode(enc2, Data::create(key));
log("Dec: "+dec->toString());
log("Dec2: "+dec2->toString());
}
void ManualImage2ImageRegistrationWidget::updateAverageAccuracyLabel()
{
QString fixedName;
QString movingName;
DataPtr fixedData = boost::dynamic_pointer_cast<Data>(mServices->registration()->getFixedData());
DataPtr movingData = boost::dynamic_pointer_cast<Data>(mServices->registration()->getMovingData());
if (fixedData)
fixedName = fixedData->getName();
if (movingData)
movingName = movingData->getName();
int numberOfActiveLandmarks = 0;
if(this->isAverageAccuracyValid(numberOfActiveLandmarks))
{
mAvarageAccuracyLabel->setText(tr("Root mean square accuracy (Landmarks) %1 mm, calculated in %2 landmarks").
arg(this->getAverageAccuracy(numberOfActiveLandmarks), 0, 'f', 2).arg(numberOfActiveLandmarks));
mAvarageAccuracyLabel->setToolTip(QString("Root Mean Square landmark accuracy from target [%1] to fixed [%2].").
arg(movingName).arg(fixedName));
}
else
{
mAvarageAccuracyLabel->setText(" ");
mAvarageAccuracyLabel->setToolTip("");
}
}
void TestSharedPtr::testSharedPtrDict()
{
QHash<DataPtr, int> dict;
DataPtr nullPtr = Data::createNull();
dict[nullPtr] = 1;
QCOMPARE(dict.size(), 1);
QCOMPARE(dict[nullPtr], 1);
DataPtr validPtr1 = Data::create();
QCOMPARE(qHash(validPtr1.data()), qHash(validPtr1));
dict[validPtr1] = 2;
QCOMPARE(dict.size(), 2);
QCOMPARE(dict[nullPtr], 1);
QCOMPARE(dict[validPtr1], 2);
DataPtr validPtr2 = validPtr1;
QCOMPARE(validPtr1.data(), validPtr2.data());
QCOMPARE(qHash(validPtr1), qHash(validPtr2));
dict[validPtr2] = 3;
QCOMPARE(dict.size(), 2);
QCOMPARE(dict[nullPtr], 1);
QCOMPARE(dict[validPtr1], 3);
QCOMPARE(dict[validPtr2], 3);
DataPtr validPtrAlternative = Data::create();
QVERIFY(validPtr1.data() != validPtrAlternative.data());
QVERIFY(validPtr1 != validPtrAlternative);
QVERIFY(qHash(validPtr1) != qHash(validPtrAlternative));
dict[validPtrAlternative] = 4;
QCOMPARE(dict.size(), 3);
QCOMPARE(dict[nullPtr], 1);
QCOMPARE(dict[validPtr1], 3);
QCOMPARE(dict[validPtr2], 3);
QCOMPARE(dict[validPtrAlternative], 4);
}
BOOST_FIXTURE_TEST_CASE(manyReferenceTimesAndValidTimesCreatesTimeOffsetVariable, TimeHandlerFixture)
{
add("2011-05-29 00:00:00", "2011-05-29 00:00:00");
add("2011-05-30 00:00:00", "2011-05-29 00:00:00");
add("2011-05-30 00:00:00", "2011-05-30 00:00:00");
add("2011-05-31 00:00:00", "2011-05-30 00:00:00");
WdbIndex index(gridData());
TimeHandler timeHandler(index);
timeHandler.addToCdm(cdm);
const CDMVariable & offsetVar = cdm.getVariable(TimeHandler::timeOffsetName);
DataPtr d = timeHandler.getData(offsetVar, 0);
BOOST_REQUIRE_EQUAL(2, d->size());
boost::shared_array<double> array = d->asDouble();
BOOST_CHECK_EQUAL(0, array[0]);
BOOST_CHECK_EQUAL(24*60*60, array[1]);
const std::vector<std::string> & shape = offsetVar.getShape();
BOOST_REQUIRE_EQUAL(1, shape.size());
BOOST_CHECK_EQUAL(TimeHandler::timeOffsetName, shape[0]);
CHECK_ATTRIBUTE(TimeHandler::timeOffsetName, "long_name", "offset since referenceTime");
CHECK_ATTRIBUTE(TimeHandler::timeOffsetName, "units", "seconds");
const CDMDimension & dim = cdm.getDimension(TimeHandler::timeOffsetName);
BOOST_CHECK_EQUAL(2, dim.getLength());
}
void SkinExportSerializer::writeStateText(pugi::xml_node _parent, DataPtr _data, const MyGUI::IntCoord& _value)
{
pugi::xml_node node = _parent.append_child("State");
node.append_attribute("name").set_value(convertEditorToExportStateName(_data->getPropertyValue("Name")).c_str());
node.append_attribute("colour").set_value(_data->getPropertyValue("TextColour").c_str());
node.append_attribute("shift").set_value(_data->getPropertyValue("TextShift").c_str());
}
Serializable* ExporterBackend::buildTexture(CSLImage* image, CSIBCPixMap& pixMap)
{
uint depth = pixMap.GetTotalPixelDepthByte();
// We only handly 32 bit and 24bit textures right now
if (depth != 4 && depth != 3)
{
ZENIC_WARNING("Unsupported pixeldepth (" << pixMap.GetTotalPixelDepthByte() << ") for texture " << image->GetSourceFile() <<
"skipping");
return 0;
}
Texture* texture = zenic_new Texture;
TextureData* textureData = zenic_new TextureData;
textureData->setWidth(u16(pixMap.GetWidth()));
textureData->setHeight(u16(pixMap.GetHeight()));
textureData->setFlags(TextureData::RGB);
DataPtr<u8> imageData;
uint imageSize = pixMap.GetWidth() * pixMap.GetHeight() * depth;
imageData.allocate(imageSize);
memcpy(imageData.objects(), pixMap.GetMap(), imageSize);
textureData->setImageData(imageData);
texture->setData(textureData);
return texture;
}
void RegistrationImplService::doPatientRegistration()
{
DataPtr fixedImage = this->getFixedData();
if(!fixedImage)
{
reportError("The fixed data is not set, cannot do patient registration!");
return;
}
LandmarkMap fixedLandmarks = fixedImage->getLandmarks()->getLandmarks();
LandmarkMap toolLandmarks = mPatientModelService->getPatientLandmarks()->getLandmarks();
this->writePreLandmarkRegistration(fixedImage->getName(), fixedImage->getLandmarks()->getLandmarks());
this->writePreLandmarkRegistration("physical", toolLandmarks);
std::vector<QString> landmarks = this->getUsableLandmarks(fixedLandmarks, toolLandmarks);
vtkPointsPtr p_ref = this->convertTovtkPoints(landmarks, fixedLandmarks, fixedImage->get_rMd());
vtkPointsPtr p_pr = this->convertTovtkPoints(landmarks, toolLandmarks, Transform3D::Identity());
// ignore if too few data.
if (p_ref->GetNumberOfPoints() < 3)
return;
bool ok = false;
Transform3D rMpr = this->performLandmarkRegistration(p_pr, p_ref, &ok);
if (!ok)
{
reportError("P-I Landmark registration: Failed to register: [" + qstring_cast(p_pr->GetNumberOfPoints()) + "p]");
return;
}
this->applyPatientRegistration(rMpr, "Patient Landmark");
}
QString StringPropertyRegistrationMovingImage::getValue() const
{
DataPtr image = mRegistrationService->getMovingData();
if (!image)
return "";
return qstring_cast(image->getUid());
}
std::vector<PointsPrimitivePtr> IECoreScene::PointsAlgo::segment(
const PointsPrimitive *points,
const PrimitiveVariable &primitiveVariable,
const IECore::Data *segmentValues
)
{
DataPtr data;
if( !segmentValues )
{
data = IECore::uniqueValues( primitiveVariable.data.get() );
segmentValues = data.get();
}
std::string primitiveVariableName;
for (const auto &pv : points->variables )
{
if ( pv.second == primitiveVariable )
{
primitiveVariableName = pv.first;
}
}
if( primitiveVariableName == "" )
{
throw IECore::InvalidArgumentException( "IECoreScene::PointsAlgo::segment : Primitive variable not found on Points Primitive" );
}
auto f = PointsAlgo::deletePoints;
IECoreScene::Detail::TaskSegmenter<IECoreScene::PointsPrimitive, decltype(f) > segmenter( points, const_cast<IECore::Data*> (segmentValues), primitiveVariableName, f);
return dispatch( primitiveVariable.data.get(), segmenter );
}
/** Return transform from target space to reference space
*
*/
Transform3D ImageLandmarksWidget::getTargetTransform() const
{
DataPtr image = this->getCurrentData();
if (!image)
return Transform3D::Identity();
return image->get_rMd();
}
void
FreezeScript::AssignVisitor::visitSequence(const SequenceDataPtr& dest)
{
Slice::TypePtr type = dest->getType();
SequenceDataPtr src = SequenceDataPtr::dynamicCast(_src);
if(src && isCompatible(type, src->getType()))
{
DataList& srcElements = src->getElements();
DataList destElements;
Slice::SequencePtr seqType = Slice::SequencePtr::dynamicCast(type);
assert(seqType);
Slice::TypePtr elemType = seqType->type();
string typeName = typeToString(type);
for(DataList::const_iterator p = srcElements.begin(); p != srcElements.end(); ++p)
{
DataPtr element = _factory->create(elemType, false);
Destroyer<DataPtr> elementDestroyer(element);
AssignVisitor v(*p, _factory, _errorReporter, _convert, typeName + " element");
element->visit(v);
destElements.push_back(element);
elementDestroyer.release();
}
DataList& l = dest->getElements();
l.swap(destElements);
}
else
{
typeMismatchError(type, _src->getType());
}
}
Context::Context( const Context &other, Ownership ownership )
: m_map( other.m_map ), m_changedSignal( NULL )
{
// We used the (shallow) Map copy constructor in our initialiser above
// because it offers a big performance win over iterating and inserting copies
// ourselves. Now we need to go in and tweak our copies based on the ownership.
for( Map::iterator it = m_map.begin(), eIt = m_map.end(); it != eIt; ++it )
{
it->second.ownership = ownership;
switch( ownership )
{
case Copied :
{
DataPtr valueCopy = it->second.data->copy();
it->second.data = valueCopy.get();
it->second.data->addRef();
break;
}
case Shared :
it->second.data->addRef();
break;
case Borrowed :
// no need to do anything
break;
}
}
}
QString ImageLandmarksWidget::getTargetName() const
{
DataPtr image = this->getCurrentData();
if (!image)
return "None";
return image->getName();
}
KeyStorage::DecodeKey KeyStorage::getWifiDecodeKey(
const std::string& ssid,
const std::string& bssid)
{
DecodeKey result;
static Data salt1("MCeGNFxMgyswwJfn6zCf");
static Data salt2("MfcLVmEF95tF6Sa6627e");
static Data salt3("5aU3a9EmyuwyyTRss7wM");
DataPtr res = Data::create(salt1);
res += ssid;
res += salt2;
res += bssid;
res += salt3;
DataPtr hash = Hash::apply(res);
if(hash)
{
Data::ByteArr& raw = hash->getRawData();
if(raw.size() >= Protect::KEY_SIZE + Protect::IV_SIZE)
{
DataPtr key = Data::create(&raw[0], Protect::KEY_SIZE);
DataPtr iv = Data::create(&raw[0]+Protect::KEY_SIZE, Protect::IV_SIZE);
result.key = key;
result.iv = iv;
}
}
return result;
}
DataPtr DataManagerImpl::loadData(const QString& uid, const QString& path)
{
if (mData.count(uid)) // dont load same image twice
return mData[uid];
QString type = DataReaderWriter().findDataTypeFromFile(path);
if(!mDataFactory)
reportError("DataManagerImpl::loadData() Got no DataFactory");
DataPtr data = mDataFactory->create(type, uid);
if (!data)
{
reportError("Failed to find loaded for: [" + path + "]");
return DataPtr();
}
bool loaded = data->load(path);
if (!loaded)
{
reportError("Failed to load file: [" + path + "]");
return DataPtr();
}
this->loadData(data);
return data;
}
BOOST_FIXTURE_TEST_CASE(manyReferenceTimesAndValidTimes, TimeHandlerFixture)
{
add("2011-05-29 00:00:00", "2011-05-29 00:00:00");
add("2011-05-30 00:00:00", "2011-05-29 00:00:00");
add("2011-05-30 00:00:00", "2011-05-30 00:00:00");
add("2011-05-31 00:00:00", "2011-05-30 00:00:00");
WdbIndex index(gridData());
TimeHandler timeHandler(index);
timeHandler.addToCdm(cdm);
GridData::Time referenceTime1 = boost::posix_time::time_from_string("2011-05-29 00:00:00");
const CDMVariable & refTimeVar = cdm.getVariable(TimeHandler::referenceTimeName);
BOOST_CHECK_EQUAL(referenceTime1, timeFromData(timeHandler.getData(refTimeVar, 0)));
const CDMVariable & timeVar = cdm.getVariable(TimeHandler::validTimeName);
DataPtr times = timeHandler.getData(timeVar, 0);
GridData::Time validTime1 = boost::posix_time::time_from_string("2011-05-29 00:00:00");
GridData::Time validTime2 = boost::posix_time::time_from_string("2011-05-30 00:00:00");
BOOST_REQUIRE_EQUAL(2, times->size());
BOOST_CHECK_EQUAL(validTime1, timeFromData(times, 0));
BOOST_CHECK_EQUAL(validTime2, timeFromData(times, 1));
}
void FontExportSerializer::generateFont(DataPtr _data)
{
std::string fontName = _data->getPropertyValue("FontName");
removeFont(fontName);
std::string resourceCategory = MyGUI::ResourceManager::getInstance().getCategoryName();
MyGUI::ResourceTrueTypeFont* font = MyGUI::FactoryManager::getInstance().createObject<MyGUI::ResourceTrueTypeFont>(resourceCategory);
font->setResourceName(fontName);
font->setSource(_data->getPropertyValue("Source"));
font->setSize(_data->getPropertyValue<float>("Size"));
font->setResolution(_data->getPropertyValue<int>("Resolution"));
font->setHinting(_data->getPropertyValue("Hinting"));
font->setAntialias(_data->getPropertyValue<bool>("Antialias"));
font->setTabWidth(_data->getPropertyValue<float>("TabWidth"));
font->setOffsetHeight(_data->getPropertyValue<int>("OffsetHeight"));
font->setSubstituteCode(_data->getPropertyValue<int>("SubstituteCode"));
font->setDistance(_data->getPropertyValue<int>("Distance"));
std::string ranges = _data->getPropertyValue("FontCodeRanges");
std::vector<std::string> values = MyGUI::utility::split(ranges, "|");
for (size_t index = 0; index < values.size(); index ++)
{
MyGUI::IntSize size = MyGUI::IntSize::parse(values[index]);
font->addCodePointRange(size.width, size.height); // о да
}
font->initialise();
MyGUI::ResourceManager::getInstance().addResource(font);
}
void ImageLandmarksWidget::setTargetLandmark(QString uid, Vector3D p_target)
{
DataPtr image = this->getCurrentData();
if (!image)
return;
image->getLandmarks()->setLandmark(Landmark(uid, p_target));
}
void ImageLandmarksWidget::importPointMetricsToLandmarkButtonClickedSlot()
{
DataPtr image = this->getCurrentData();
if(!image)
return;
std::map<QString, DataPtr> point_metrics = mServices->patient()->getChildren(image->getUid(), "pointMetric");
std::map<QString, DataPtr>::iterator it = point_metrics.begin();
//Make sure we have enough landmarks
int number_of_landmarks = mServices->patient()->getLandmarkProperties().size();
int number_of_metrics = point_metrics.size();
for(int i=number_of_landmarks; i<number_of_metrics; ++i)
{
QString uid = mServices->patient()->addLandmark();
}
for(; it != point_metrics.end(); ++it)
{
PointMetricPtr point_metric = boost::static_pointer_cast<PointMetric>(it->second);
if(!point_metric)
continue;
Vector3D pos_x = point_metric->getCoordinate();
//Transform3D d_M_x = mServices->spaceProvider()->get_toMfrom(CoordinateSystem::fromString(image->getSpace()), point_metric->getSpace());
//Vector3D pos_d = d_M_x.coord(pos_x);
QString point_metric_name = point_metric->getName();
image->getLandmarks()->setLandmark(Landmark(point_metric_name, pos_x));
this->activateLandmark(point_metric_name);
}
}
LandmarkMap ImageLandmarksWidget::getTargetLandmarks() const
{
DataPtr image = this->getCurrentData();
if (!image)
return LandmarkMap();
return image->getLandmarks()->getLandmarks();
}
void FontTryControl::updateFont()
{
DataPtr data = DataUtility::getSelectedDataByType("Font");
if (data != nullptr)
mEdit->setFontName(data->getPropertyValue("FontName"));
else
mEdit->setFontName("");
}
void EncodingBinaryNative_toObjectImpl(
DataPtr & data,
T * t,
int nCount)
{
RCF_ASSERT_EQ( data.length() , sizeof(T)*nCount);
memcpy(t, data.get(), sizeof(T)*nCount);
}
void ImageExportSerializer::writeImage(pugi::xml_node _parent, DataPtr _data)
{
pugi::xml_node node = _parent.append_child("Resource");
node.append_attribute("type").set_value("ResourceImageSet");
node.append_attribute("name").set_value(_data->getPropertyValue("Name").c_str());
for (Data::VectorData::const_iterator child = _data->getChilds().begin(); child != _data->getChilds().end(); child ++)
writeGroup(node, (*child));
}
inline void encodeTypedElements( BinaryPortable *, T *, DataPtr &data, T *t, int nCount)
{
UInt32 nBufferSize = sizeof(T) * nCount;
UInt32 nAlloc = data.allocate(nBufferSize);
RCF_ASSERT(nAlloc == nBufferSize);
T *buffer = reinterpret_cast<T *>(data.get());
memcpy(buffer, t, nBufferSize);
RCF::machineToNetworkOrder(buffer, sizeof(T), nCount);
}
Imath::Box3f SceneGadget::bound() const
{
if( m_updateErrored )
{
return Box3f();
}
DataPtr d = m_renderer->command( "gl:queryBound" );
return static_cast<Box3fData *>( d.get() )->readable();
}
void ImageExportSerializer::writeFrame(pugi::xml_node _parent, DataPtr _data)
{
pugi::xml_node node = _parent.append_child("Frame");
node.append_attribute("point").set_value(_data->getPropertyValue("Point").c_str());
size_t count = MyGUI::utility::parseValue<size_t>(_data->getPropertyValue("Count"));
if (count > 1)
node.append_attribute("count").set_value(MyGUI::utility::toString(count).c_str());
}
void FontExportSerializer::serialization(pugi::xml_document& _doc)
{
pugi::xml_node root = _doc.append_child("MyGUI");
root.append_attribute("type").set_value("Resource");
root.append_attribute("version").set_value("1.1");
DataPtr data = DataManager::getInstance().getRoot();
for (Data::VectorData::const_iterator child = data->getChilds().begin(); child != data->getChilds().end(); child ++)
writeFont(root, (*child));
}
