void FITS_IO::writeType(const std::string& filename, std::shared_ptr<const IImage> img, int imgType, int bitPixType, int dim) {
if (Common::File::exists(filename)) {
Common::File::remove(filename);
}
int status = 0;
fitsfile *fitsFilePtr;
ffinit(&fitsFilePtr, filename.c_str(), &status);
if (status) throw Common::Exception() << "ffinit failed with " << status;
long sizes[3] = {img->getSize()(0), img->getSize()(1), dim};
status = ffphps(fitsFilePtr, bitPixType, 3, sizes, &status);
if (status) throw Common::Exception() << "ffphps failed with " << status;
long int firstpix[3];
for (int i = 0; i < 3; i++) {
firstpix[i] = 1;
}
int numPixels = img->getSize()(0) * img->getSize()(1) * dim;
ffppx(fitsFilePtr, imgType, firstpix, numPixels, (void*)img->getData(), &status);
if (status) throw Common::Exception() << "ffppx failed with " << status;
ffclos(fitsFilePtr, &status);
if (status) throw Common::Exception() << "ffclos failed with " << status;
}
void BufferCLGL2RAMConverter::update(std::shared_ptr<const BufferCLGL> src,
std::shared_ptr<BufferRAM> dst) const {
if (src->getSize() != dst->getSize()) {
dst->setSize(src->getSize());
}
src->getBufferGL()->download(dst->getData());
}
std::shared_ptr<BufferGL> BufferRAM2GLConverter::createFrom(
std::shared_ptr<const BufferRAM> bufferRAM) const {
auto buffer = std::make_shared<BufferGL>(bufferRAM->getSize(), bufferRAM->getDataFormat(),
bufferRAM->getBufferUsage(), bufferRAM->getBufferTarget());
buffer->upload(bufferRAM->getData(), bufferRAM->getSize() * bufferRAM->getSizeOfElement());
return buffer;
}
void BufferRAM2CLConverter::update(std::shared_ptr<const BufferRAM> src,
std::shared_ptr<BufferCL> dst) const {
if (src->getSize() != dst->getSize()) {
dst->setSize(src->getSize());
}
dst->upload(src->getData(), src->getSize() * src->getSizeOfElement());
}
TileObjectCollidable::TileObjectCollidable(TileMap &map, Vec3<float> position, Vec3<int> tileSizeInVoxels, std::shared_ptr<VoxelMap> voxels)
: TileObject(map, position),
tileSizeInVoxels(tileSizeInVoxels), voxels(voxels)
{
this->collides = true;
this->bounds.x = (voxels->getSize().x + (tileSizeInVoxels.x - 1)) / tileSizeInVoxels.x;
this->bounds.y = (voxels->getSize().y + (tileSizeInVoxels.y - 1)) / tileSizeInVoxels.y;
this->bounds.z = (voxels->getSize().z + (tileSizeInVoxels.z - 1)) / tileSizeInVoxels.z;
}
int64_t PutSQL::SQLReadCallback::process(std::shared_ptr<io::BaseStream> stream) {
sql_->resize(stream->getSize());
auto num_read = static_cast<uint64_t >(stream->readData(reinterpret_cast<uint8_t *>(&(*sql_)[0]),
static_cast<int>(stream->getSize())));
if (num_read != stream->getSize()) {
throw std::runtime_error("SQLReadCallback failed to fully read flow file input stream");
}
return num_read;
}
void BufferCLGL2CLConverter::update(std::shared_ptr<const BufferCLGL> src,
std::shared_ptr<BufferCL> dst) const {
if (src->getSize() != dst->getSize()) {
dst->setSize(src->getSize());
}
{
SyncCLGL glSync;
glSync.addToAquireGLObjectList(src.get());
glSync.aquireAllObjects();
OpenCL::getPtr()->getQueue().enqueueCopyBuffer(src->get(), dst->get(), 0, 0,
src->getSize() * src->getSizeOfElement());
}
}
std::shared_ptr<BufferCL> BufferCLGL2CLConverter::createFrom(
std::shared_ptr<const BufferCLGL> src) const {
size_t size = src->getSize();
auto destination =
std::make_shared<BufferCL>(size, src->getDataFormat(), src->getBufferUsage());
{
SyncCLGL glSync;
glSync.addToAquireGLObjectList(src.get());
glSync.aquireAllObjects();
OpenCL::getPtr()->getQueue().enqueueCopyBuffer(src->get(), destination->get(), 0, 0,
src->getSize() * src->getSizeOfElement());
}
return destination;
}
void cloudCallback (const typename pcl::PointCloud<PointType>::ConstPtr& cloud, size_t index) {
bool overwrite = false;
bool pushed = false;
{
std::unique_lock<std::mutex> lock(mutex_);
if (!temp_buffer_element_->isCloudSetAt(index)) {
temp_buffer_element_->setCloudAt(cloud, index);
if(isBufferElementFullyEmpty())
first_set_stamp = cloud->header.stamp;
else if (isBufferElementFullySet() || isItTimeToPushElement(cloud->header.stamp)) {
overwrite = buffer_->pushBack(temp_buffer_element_);
pushed = true;
temp_buffer_element_ = std::make_shared<MultiCloudAndImage<PointType>>();
// first_set_stamp = cloud->header.stamp;
}
}
else {
overwrite = buffer_->pushBack(temp_buffer_element_);
pushed = true;
temp_buffer_element_ = std::make_shared<MultiCloudAndImage<PointType>>();
temp_buffer_element_->setCloudAt(cloud, index);
first_set_stamp = cloud->header.stamp;
}
}
if(pushed) {
if(overwrite)
Logger::log(Logger::WARN, "Warning! CloudAndImage Buffer was full, overwriting data!\n");
}
if(cloud_timers_->at(index)->time())
Logger::log(Logger::INFO, "MultiCloudImage Buffer size: %zd.\n", buffer_->getSize());
}
FlowFileRecord::FlowFileRecord(std::shared_ptr<core::Repository> flow_repository, const std::shared_ptr<core::ContentRepository> &content_repo, std::shared_ptr<core::FlowFile> &event,
const std::string &uuidConnection)
: FlowFile(),
snapshot_(""),
content_repo_(content_repo),
flow_repository_(flow_repository) {
entry_date_ = event->getEntryDate();
lineage_start_date_ = event->getlineageStartDate();
lineage_Identifiers_ = event->getlineageIdentifiers();
uuidStr_ = event->getUUIDStr();
attributes_ = event->getAttributes();
size_ = event->getSize();
offset_ = event->getOffset();
event->getUUID(uuid_);
uuid_connection_ = uuidConnection;
if (event->getResourceClaim()) {
event->getResourceClaim()->increaseFlowFileRecordOwnedCount();
content_full_fath_ = event->getResourceClaim()->getContentFullPath();
}
if (event->getFlowIdentifier()) {
std::string attr;
event->getAttribute(FlowAttributeKey(FlowAttribute::FLOW_ID), attr);
setFlowIdentifier(event->getFlowIdentifier());
if (!attr.empty()) {
addKeyedAttribute(FlowAttribute::FLOW_ID, attr);
}
}
}
void cloudCallback (const typename pcl::PointCloud<PointType>::ConstPtr& cloud) {
bool overwrite = false;
bool pushed = false;
{
std::unique_lock<std::mutex> lock(mutex_);
if (!temp_buffer_element_->isCloudSet()) {
temp_buffer_element_->setCloud(cloud);
if (temp_buffer_element_->isImageSet() || !provides_images_) {
overwrite = buffer_->pushBack(temp_buffer_element_);
pushed = true;
temp_buffer_element_ = std::make_shared<CloudAndImage<PointType>>();
}
}
else {
overwrite = buffer_->pushBack(temp_buffer_element_);
pushed = true;
temp_buffer_element_ = std::make_shared<CloudAndImage<PointType>>();
temp_buffer_element_->setCloud(cloud);
}
}
if(pushed) {
if(overwrite)
Logger::log(Logger::WARN, "Warning! CloudAndImage Buffer was full, overwriting data!\n");
}
if(cloud_timer_->time())
Logger::log(Logger::INFO, "CloudImage Buffer size: %zd.\n", buffer_->getSize());
}
void imageCallback(const pcl::io::Image::Ptr& image) {
bool overwrite = false;
bool pushed = false;
{
std::unique_lock<std::mutex> lock(mutex_);
if (!temp_buffer_element_->isImageSet()) {
temp_buffer_element_->setImage(image);
if (temp_buffer_element_->isCloudSet()) {
overwrite = buffer_->pushBack(temp_buffer_element_);
pushed = true;
temp_buffer_element_ = std::make_shared<CloudAndImage<PointType>>();
}
}
else {
overwrite = buffer_->pushBack(temp_buffer_element_);
pushed = true;
temp_buffer_element_ = std::make_shared<CloudAndImage<PointType>>();
temp_buffer_element_->setImage(image);
}
}
if(pushed) {
if(overwrite)
Logger::log(Logger::WARN, "Warning! CloudAndImage Buffer was full, overwriting data!\n");
}
if(image_timer_->time())
Logger::log(Logger::INFO, "CloudImage Buffer size: %zd.\n", buffer_->getSize());
}
bool File::write(std::shared_ptr<Data> data)
{
if (good() && !isRead() && isBinary())
{
handle.write(reinterpret_cast<char *>(data->getBuffer()), data->getSize());
}
return false;
}
void VoxelMap::setSlice(int z, std::shared_ptr<VoxelSlice> slice)
{
if (z < 0 || (unsigned)z >= this->slices.size())
{
LogError("Trying to set slice %d in a {%d,%d,%d} sized voxelMap",
z, this->size.x, this->size.y, this->size.z);
return;
}
if (slice->getSize() != Vec2<int>{this->size.x, this->size.y})
{
LogError("Trying to set slice of size {%d,%d} in {%d,%d,%d} sized voxelMap",
slice->getSize().x, slice->getSize().y,
this->size.x, this->size.y, this->size.z);
return;
}
this->slices[z] = slice;
}
int64_t process(std::shared_ptr<org::apache::nifi::minifi::io::BaseStream> stream) {
int64_t ret = 0;
ret = stream->read(buffer_, buffer_size_);
if (stream)
read_size_ = stream->getSize();
else
read_size_ = buffer_size_;
return ret;
}
std::shared_ptr<gui::controller::ButtonController> ButtonFactory::create(std::shared_ptr<gui::model::ButtonModel> model,
std::shared_ptr<gui::controller::AbstractWindowedController> container)
{
int window_style = WS_CHILD | WS_TABSTOP; // BS_DEFPUSHBUTTON
if (model->isVisible())
window_style |= WS_VISIBLE;
int button_id = IdProvider::getInstance()->generateId();
HWND hWnd = CreateWindowEx (0,
"BUTTON",
model->getText().c_str(),
window_style,
model->getLocation()->getX(),
model->getLocation()->getY(),
model->getSize()->getWidth(),
model->getSize()->getHeight(),
container->getHWnd(),
(HMENU)button_id,
Application::getInstance()->getHInstance(),
0);
if (!hWnd)
throw SystemError( SystemError::getLastErrorMessage() );
std::shared_ptr<controller::ButtonController> controller =
std::make_shared<controller::ButtonController>( hWnd, button_id );
controller->setButtonModel (model);
controller->setName (model->getName());
if (model->getFontModel())
{
gui::factory::FontFactory font_factory;
std::shared_ptr<gui::handler::FontHandler> font_handler = font_factory.create (model->getFontModel());
controller->setFontHandler (font_handler);
}
// Register controller on MessageDispatcher
MessageDispatcher::getInstance()->registerController (controller);
return controller;
}
string Folder::generateData(std::shared_ptr<FileEntry> entry){
string data = entry->getName() + ';';
data += to_string(entry->getSize()) + ';';
data += to_string(entry->getCreationTime()) + ';';
data += to_string(entry->getModificationTime()) + ';';
data += to_string(entry->getAccessTime()) + ';';
data += to_string(entry->getInitialBlock()) + ';';
data += to_string(entry->isFolder()) + ';';
return data;
}
void MSEFunctor::getDiff(const std::shared_ptr<DataBucket> labelDataBucket,
const std::shared_ptr<DataBucket> outputDataBucket, std::shared_ptr<DataBucket>& diff)
{
const DataSize labelSize = labelDataBucket->getSize();
const DataSize outputSize = outputDataBucket->getSize();
const DataSize diffSize = diff->getSize();
diff->fillData(0.0f);
for (size_t on = 0; on < outputSize.number; on++)
{
const float* labelData = labelDataBucket->getData().get() + on*labelSize._3DSize();
const float* outputData = outputDataBucket->getData().get() + on*outputSize._3DSize();
float* diffData = diff->getData().get() + on*diffSize._3DSize();
for (size_t nextDiffIdx = 0; nextDiffIdx < diffSize._3DSize(); nextDiffIdx++)
{
const size_t dataIdx = nextDiffIdx;
diffData[nextDiffIdx] += 2.0f*(outputData[dataIdx] - labelData[dataIdx]);
}
}
}
std::shared_ptr<BufferRAM> BufferGL2RAMConverter::createFrom(
std::shared_ptr<const BufferGL> src) const {
auto dst = createBufferRAM(src->getSize(), src->getDataFormat(), src->getBufferUsage(), src->getBufferTarget());
if (!dst)
throw ConverterException(std::string("Cannot convert format from GL to RAM: ") +
src->getDataFormat()->getString(),
IvwContext);
src->download(dst->getData());
return dst;
}
std::shared_ptr<BufferRAM> BufferCLGL2RAMConverter::createFrom(
std::shared_ptr<const BufferCLGL> src) const {
size_t size = src->getSize();
auto destination = createBufferRAM(size, src->getDataFormat(), src->getBufferUsage());
if (destination) {
src->getBufferGL()->download(destination->getData());
} else {
LogError("Invalid conversion or not implemented");
}
return destination;
}
//////////////////////////////////////////////////////////////////////////
//cross entropy
float CrossEntropyFunctor::getLoss(const std::shared_ptr<DataBucket> labelDataBucket,
const std::shared_ptr<DataBucket> outputDataBucket)
{
const auto outputSize = outputDataBucket->getSize();
const float* labelData = labelDataBucket->getData().get();
const float* outputData = outputDataBucket->getData().get();
float loss = 0.0f;
for (size_t i = 0; i < outputSize.totalSize(); i++)
{
const float curLoss = -labelData[i] * std::log(outputData[i]);
loss = moving_average(loss, i+1, curLoss);
}
return loss*outputSize._3DSize();
}
void test_read_write_mix(const uint8_t* buf, uint32_t buf_len,
const std::shared_ptr<SizeGenerator>& write_gen,
const std::shared_ptr<SizeGenerator>& read_gen) {
// Try it with a mix of read/write sizes.
std::shared_ptr<TMemoryBuffer> membuf(new TMemoryBuffer());
std::shared_ptr<TZlibTransport> zlib_trans(new TZlibTransport(membuf));
unsigned int tot;
tot = 0;
while (tot < buf_len) {
uint32_t write_len = write_gen->getSize();
if (tot + write_len > buf_len) {
write_len = buf_len - tot;
}
zlib_trans->write(buf + tot, write_len);
tot += write_len;
}
zlib_trans->finish();
tot = 0;
boost::shared_array<uint8_t> mirror(new uint8_t[buf_len]);
while (tot < buf_len) {
uint32_t read_len = read_gen->getSize();
uint32_t expected_read_len = read_len;
if (tot + read_len > buf_len) {
expected_read_len = buf_len - tot;
}
uint32_t got = zlib_trans->read(mirror.get() + tot, read_len);
BOOST_REQUIRE_LE(got, expected_read_len);
BOOST_REQUIRE_NE(got, 0);
tot += got;
}
BOOST_CHECK_EQUAL(memcmp(mirror.get(), buf, buf_len), 0);
zlib_trans->verifyChecksum();
}
bool HGTController::expandDiff(CourgetteInstance* ci, std::shared_ptr<MCFCore::MCFFile> file)
{
m_hFile.close();
UTIL::FS::Path path(m_szInstallDir, file->getName(), false);
path += file->getPath();
gcString oldFile = path.getFullPath();
gcString diffFile("{0}_diff", m_szFile);
try
{
UTIL::FS::FileHandle fhSrc(m_szFile, UTIL::FS::FILE_READ);
UTIL::FS::FileHandle fhDest(diffFile.c_str(), UTIL::FS::FILE_WRITE);
fhSrc.seek(file->getOffSet());
decompressDiff(file->getDiffSize(), fhSrc, fhDest);
UTIL::FS::delFile(diffFile);
}
catch (gcException)
{
UTIL::FS::delFile(diffFile);
return false;
}
MD5Progressive md5;
try
{
m_hFile.open(m_szFile, UTIL::FS::FILE_APPEND);
m_hFile.seek(file->getOffSet());
}
catch (...)
{
return false;
}
uint64 fsize = file->getSize();
uint64 tot = 0;
bool res = ci->applyDiff(oldFile.c_str(), diffFile.c_str(), [this, &md5, &tot, fsize](const char* buff, size_t size) -> bool
{
md5.update(buff, size);
return writeDiff(tot, fsize, buff, size);
});
return (res && md5.finish() == file->getCsum());
}
/**
* Unmarshall stats from a flat buffer.
* Note: the scidb::SharedBuffer is a thin wrapper over a block of allocated memory.
* @param statData the buffer of data; must be exactly getMarshalledSize() bytes.
*/
Stats(std::shared_ptr<SharedBuffer>& statData)
{
/* assert-like defensive exception */
if (statData->getSize() != getMarshalledSize())
{
throw SYSTEM_EXCEPTION(SCIDB_SE_INTERNAL, SCIDB_LE_ILLEGAL_OPERATION)
<< "Received a statistics data buffer of incorrect size";
}
size_t* ptr = static_cast<size_t*> (statData->getData());
chunkCount = *ptr;
++ptr;
cellCount = *ptr;
++ptr;
minCellsPerChunk = *ptr;
++ptr;
maxCellsPerChunk = *ptr;
++ptr;
}
std::shared_ptr<BufferCL> BufferRAM2CLConverter::createFrom(
std::shared_ptr<const BufferRAM> bufferRAM) const {
return std::make_shared<BufferCL>(bufferRAM->getSize(), bufferRAM->getDataFormat(),
bufferRAM->getBufferUsage(), bufferRAM->getData());
}
ExtractText::ReadCallback::ReadCallback(std::shared_ptr<core::FlowFile> flowFile, core::ProcessContext *ctx)
: flowFile_(flowFile),
ctx_(ctx) {
buffer_.reserve(std::min<uint64_t>(flowFile->getSize(), MAX_BUFFER_SIZE));
}
std::shared_ptr<BufferRAM> BufferCL2RAMConverter::createFrom(
std::shared_ptr<const BufferCL> src) const {
auto dst = createBufferRAM(src->getSize(), src->getDataFormat(), src->getBufferUsage());
src->download(dst->getData());
return dst;
}
std::string ShoeLastTemplateDao::addShoeLastTemplate(std::shared_ptr<ShoeLastTemplate> temp)
{
if(temp == nullptr)
{
LoggerManager::instance()->logInfo("insert shoe last template failed, it's a null shoe last template object.");
return "";
}
if(getShoeLastTemplate(temp->getOId()) != nullptr)
return temp->getOId();
//first insert files
if(!boost::filesystem::exists(temp->getShoeLastTemplate()))
{
LoggerManager::instance()->logInfo("add shoe last template failed, file doesn't exists");
return "";
}
std::string shoeLastOId = DatabaseUtil::instance()->storeFile(temp->getShoeLastTemplate(), DatabaseUtil::instance()->getDatabase(), false);
if(shoeLastOId == "")
{
LoggerManager::instance()->logInfo("insert shoe last to database failed.");
return "";
}
temp->setShoeLastTemplate(shoeLastOId);
std::string shoeLastBottomOId = DatabaseUtil::instance()->storeFile(temp->getShoeLastTemplateBottom(), DatabaseUtil::instance()->getDatabase(), false);
if(shoeLastBottomOId == "")
{
LoggerManager::instance()->logInfo("insert shoe last bottom to database failed.");
return "";
}
temp->setShoeLastTemplateBottom(shoeLastBottomOId);
mongo::BSONObjBuilder builder;
builder.genOID().append(mongo::StringData(DBConstant::ShoeLastTemplateSizeField), temp->getSize());
builder.append(mongo::StringData(DBConstant::ShoeLastTemplateHeelHeightField), temp->getHeelHeight());
builder.append(mongo::StringData(DBConstant::ShoeLastTemplateLastField), temp->getShoeLastTemplate());
builder.append(mongo::StringData(DBConstant::ShoeLastTemplateLastBottomField), temp->getShoeLastTemplateBottom());
std::string oid = DatabaseUtil::instance()->insert(builder, DatabaseUtil::instance()->getDatabase(), DBConstant::ShoeLastTemplateCollection);
if(oid != "")
LoggerManager::instance()->logInfo("Shoe Last Template DAO insertion success.");
else
LoggerManager::instance()->logInfo("Shoe Last Template DAO insertion failed.");
return oid;
}
std::shared_ptr<BufferCLGL> BufferGL2CLGLConverter::createFrom(
std::shared_ptr<const BufferGL> src) const {
return std::make_shared<BufferCLGL>(src->getSize(), src->getDataFormat(), src->getBufferUsage(),
src->getBufferObject());
}
void BufferGL2CLGLConverter::update(std::shared_ptr<const BufferGL> src,
std::shared_ptr<BufferCLGL> dst) const {
if (src->getSize() != dst->getSize()) {
dst->setSize(src->getSize());
}
}
