void ReadDirectory::execute(DataProvider& provider)
{
if (m_files.size() == 0)
throw OperatorError(*this, "Directory is empty.");
Data* data = 0;
std::size_t index = m_currentIndex;
do
{
boost::filesystem::path file(m_files[index]);
index = (index + 1) % m_files.size();
std::string ext = file.extension().string();
std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
if (ext == ".png" || ext == ".jpg" || ext == ".jpeg")
{
data = new cvsupport::Image(file.string());
}
}
while (data == 0 && index != m_currentIndex);
m_currentIndex = index;
if (data == 0)
throw OperatorError(*this, "Found no usable file in selected directory.");
DataContainer container(data);
Id2DataPair outputDataMapper(OUTPUT, container);
provider.sendOutputData(outputDataMapper);
}
void CameraBuffer::execute(DataProvider& provider)
{
// get the input data
Id2DataPair inputMapper(INPUT);
provider.receiveInputData(inputMapper);
// try to get a free buffer
Data* buffer = 0;
try
{
buffer = m_buffers(0);
}
catch(Timeout&)
{
}
if(buffer)
{
// there was a free buffer
DataContainer bufferContainer(buffer);
// remember it in the recycling access
m_buffers.add(bufferContainer);
Id2DataPair outputMapper(OUTPUT, inputMapper.data());
Id2DataPair bufferMapper(BUFFER, bufferContainer);
Id2DataPair idMapper(INDEX, DataContainer(new UInt32(m_id)));
// send it to the output (together with the input image and the current index)
provider.sendOutputData(outputMapper && bufferMapper && idMapper);
}
// increase the index
++m_id;
}
void Split::execute(DataProvider& provider)
{
if (m_storedItems.size() == 0)
{
RecycleAccess recycle;
{
Id2DataPair input(INPUT);
provider.receiveInputData(input);
recycle.add(input.data());
}
Data* data = recycle.get();
List* list = data_cast<List>(data);
if (list == 0)
throw InputError(INPUT, *this, "Input data must be a 'List' object.");
for (std::vector<Data*>::iterator iter = list->content().begin();
iter != list->content().end(); ++iter)
{
m_storedItems.push_back(DataContainer(*iter));
}
uint64_t size = list->content().size();
list->content().clear();
delete list;
DataContainer outNumItems(new UInt64(size));
Id2DataPair dataMapper(OUTPUT_NUM_ITEMS, outNumItems);
provider.sendOutputData(dataMapper);
}
if (m_storedItems.size() != 0)
{
DataContainer outData = m_storedItems.front();
Id2DataPair dataMapper(OUTPUT_DATA, outData);
m_storedItems.pop_front();
provider.sendOutputData(dataMapper);
}
}
void ParameterOperator::execute(DataProvider& provider)
{
Id2DataPair input1(INPUT_1);
Id2DataPair input2(INPUT_2);
provider.receiveInputData(input1 && input2);
// execute...
Id2DataPair output1(OUTPUT_1, input1.data());
Id2DataPair output2(OUTPUT_2, input2.data());
provider.sendOutputData(output1 && output2);
}
void ReadGpio::execute(DataProvider& provider)
{
int value = impl::GPIORead(static_cast<int>(m_gpio));
if (-1 == value)
{
throw OperatorError(*this,
(boost::format("Failed to read from GPIO %1%.") % m_gpio).str());
}
DataContainer data(new Bool(value));
Id2DataPair output(OUTPUT, data);
provider.sendOutputData(output);
}
void Merge::execute(DataProvider& provider)
{
if (m_list == 0)
{
Id2DataPair dataMapper(INPUT_NUM_ITEMS);
provider.receiveInputData(dataMapper);
ReadAccess access(dataMapper.data());
try
{
m_numItems = toInt(access.get());
}
catch (BadCast&)
{
throw InputError(INPUT_NUM_ITEMS, *this, "Number of items must be an integer.");
}
m_list = new List();
}
if (m_list->content().size() < m_numItems)
{
RecycleAccess recycler;
{
Id2DataPair dataMapper(INPUT_DATA);
provider.receiveInputData(dataMapper);
recycler.add(dataMapper.data());
}
Data* data = recycler.get();
m_list->content().push_back(data);
}
if (m_list->content().size() == m_numItems)
{
DataContainer out(m_list);
m_list = 0;
m_numItems = 0;
Id2DataPair dataMapper(OUTPUT, out);
provider.sendOutputData(dataMapper);
}
}
void ConstData::execute(DataProvider& provider)
{
if (! valuePtr())
throw InternalError("Value has not been set");
DataContainer data;
if (m_allocateData)
{
data = DataContainer(valuePtr()->clone());
}
else
{
Data* dataPtr = 0;
if (m_recycleAccess.empty())
{
// if this is the first time the operator executes the value must
// be cloned
dataPtr = valuePtr()->clone();
}
else
{
// otherwise the value in the recycler can be reused
dataPtr = m_recycleAccess.get();
}
if (dataPtr != valuePtr())
{
// if the value was changed by the user since the last execution
// update it
delete dataPtr;
dataPtr = valuePtr()->clone();
}
// send and remember for the next execution
data = DataContainer(dataPtr);
m_recycleAccess.add(data);
}
Id2DataPair outputDataMapper(OUTPUT, data);
provider.sendOutputData( outputDataMapper);
}
void TestOperator::execute(DataProvider& provider)
{
if(m_throwException)
{
throw InternalError("Funny exception.");
}
Id2DataPair input1(INPUT_1);
Id2DataPair input2(INPUT_2);
provider.receiveInputData(input1 && input2);
// execute...
m_numExecutes++;
boost::this_thread::sleep_for(boost::chrono::milliseconds(m_sleepTime));
Id2DataPair output1(OUTPUT_1, input1.data());
Id2DataPair output2(OUTPUT_2, input2.data());
provider.sendOutputData(output1 && output2);
}
void Flicker::execute(DataProvider& provider)
{
Id2DataPair inputDataMapper(INPUT);
provider.receiveInputData(inputDataMapper);
DataContainer container = inputDataMapper.data();
WriteAccess access(container);
runtime::Image& image = access.get<runtime::Image>();
switch(image.depth())
{
case 1:
applyFlicker<uint8_t>(m_amount, image);
break;
case 2:
applyFlicker<uint16_t>(m_amount, image);
break;
default:
throw WrongInputType(INPUT, *this);
}
Id2DataPair outputDataMapper(OUTPUT, container);
provider.sendOutputData( outputDataMapper);
}
void ConvertPixelType::execute(DataProvider& provider)
{
if (m_dataFlow == MANUAL)
{
Id2DataPair srcMapper(SOURCE);
Id2DataPair destMapper(DESTINATION);
provider.receiveInputData(srcMapper && destMapper);
if(srcMapper.data() == destMapper.data())
throw InputError(DESTINATION, *this, "Destination image must not be the same image as the source image.");
ReadAccess src(srcMapper.data());
WriteAccess dest(destMapper.data());
const runtime::Image& srcImage = src.get<runtime::Image>();
runtime::Image& destImage = dest.get<runtime::Image>();
runtime::Image::PixelType pixelType = runtime::Image::PixelType((unsigned int)(m_pixelType));
unsigned int destImageSize = srcImage.width() * srcImage.height() * getDestPixelSize(pixelType);
unsigned int destImageStride = srcImage.width() * getDestPixelSize(pixelType);
if(destImage.bufferSize() < destImageSize)
throw InputError(DESTINATION, *this, "Destination image is too small.");
destImage.initializeImage(srcImage.width(), srcImage.height(), destImageStride, destImage.buffer(), pixelType);
if((srcImage.pixelType() == runtime::Image::RGB_24 || srcImage.pixelType() == runtime::Image::BGR_24)
&& (pixelType == runtime::Image::BAYERBG_8 || pixelType == runtime::Image::BAYERGB_8))
{
// this case is not handled by OpenCV
rgbToBayer(srcImage, destImage);
}
else
{
// use OpenCV for conversion
openCvConversion(srcImage, destImage);
}
Id2DataPair outputMapper(OUTPUT, destMapper.data());
provider.sendOutputData( outputMapper);
}
else // allocate destination data on the fly
{
Id2DataPair srcMapper(SOURCE);
provider.receiveInputData(srcMapper);
ReadAccess src(srcMapper.data());
const runtime::Image& srcImage = src.get<runtime::Image>();
runtime::Image::PixelType pixelType = runtime::Image::PixelType((unsigned int)(m_pixelType));
runtime::Image* destImage = new cvsupport::Image(srcImage.width(), srcImage.height(), pixelType);
DataContainer destContainer(destImage);
if((srcImage.pixelType() == runtime::Image::RGB_24 || srcImage.pixelType() == runtime::Image::BGR_24)
&& (pixelType == runtime::Image::BAYERBG_8 || pixelType == runtime::Image::BAYERGB_8))
{
// this case is not handled by OpenCV
rgbToBayer(srcImage, *destImage);
}
else
{
// use OpenCV for conversion
openCvConversion(srcImage, *destImage);
}
Id2DataPair outputMapper(OUTPUT, destContainer);
provider.sendOutputData( outputMapper);
}
}