void AbstractFramebuffer::read(const Range2Di& rectangle, Image2D& image) {
bindInternal(FramebufferTarget::Read);
const std::size_t dataSize = image.dataSize(rectangle.size());
char* const data = new char[dataSize];
(Context::current()->state().framebuffer->readImplementation)(rectangle, image.format(), image.type(), dataSize, data);
image.setData(image.format(), image.type(), rectangle.size(), data);
}
void CubeMapTexture::image(const Coordinate coordinate, const Int level, Image2D& image) {
const Vector2i size = imageSize(level);
const std::size_t dataSize = image.dataSize(size);
char* data = new char[dataSize];
(this->*Context::current()->state().texture->getCubeImageImplementation)(coordinate, level, size, image.format(), image.type(), dataSize, data);
image.setData(image.format(), image.type(), size, data);
}
void PngFile::Save(const Image2D &image, const std::string &filename, const ColorMap &colorMap, long double normalizeFactor, long double zeroLevel) throw(IOException)
{
PngFile pngFile(filename, image.Width(), image.Height());
pngFile.BeginWrite();
pngFile.SetFromImage(image, colorMap, normalizeFactor, zeroLevel);
pngFile.Close();
}
Image2D::Image2D(Image2D const& _cpy)
{
SetText(_cpy.GetText());
m_fg = _cpy.GetForegroundColor();
m_bg = _cpy.GetBackgroundColor();
m_width = _cpy.GetWidth();
m_height = _cpy.GetHeight();
}
void ImageTest::release() {
unsigned char data[] = {'c', 'a', 'f', 'e'};
Image2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 4}, data);
const unsigned char* const pointer = a.release();
CORRADE_COMPARE(pointer, data);
CORRADE_COMPARE(a.data(), nullptr);
CORRADE_COMPARE(a.size(), Vector2i());
}
Image2D TestSetGenerator::MakeGaussianData(unsigned width, unsigned height)
{
Image2D image = Image2D::MakeUnsetImage(width, height);
for(unsigned y=0;y<height;++y) {
for(unsigned x=0;x<width;++x) {
image.SetValue(x, y, RNG::Gaussian());
}
}
return image;
}
void TestSetGenerator::AddBroadbandToTestSet(Image2D& image, Mask2D& rfi, long double length, double strength, bool align, enum BroadbandShape shape)
{
size_t frequencyCount = image.Height();
unsigned step = image.Width()/11;
if(align)
{
// see vertevd.h why this is:
unsigned n = (unsigned) floor(0.5 + sqrt(0.25 + 2.0 * frequencyCount));
unsigned affectedAntennas = (unsigned) n*(double)length;
unsigned index = 0;
Logger::Debug << affectedAntennas << " of " << n << " antennas effected." << '\n';
Logger::Debug << "Affected baselines: ";
for(unsigned y=0;y<n;++y)
{
for(unsigned x=y+1;x<n;++x)
{
double a1, a2;
if(x<affectedAntennas) a1=1.0; else a1=0.0;
if(y<affectedAntennas) a2=1.0; else a2=0.0;
if(y<affectedAntennas || x<affectedAntennas)
{
Logger::Debug << x << " x " << y << ", ";
AddRfiPos(image, rfi, 3.0*strength*a1*a2, step*1, 3, index);
AddRfiPos(image, rfi, 2.5*strength*a1*a2, step*2, 3, index);
AddRfiPos(image, rfi, 2.0*strength*a1*a2, step*3, 3, index);
AddRfiPos(image, rfi, 1.8*strength*a1*a2, step*4, 3, index);
AddRfiPos(image, rfi, 1.6*strength*a1*a2, step*5, 3, index);
AddRfiPos(image, rfi, 3.0*strength*a1*a2, step*6, 1, index);
AddRfiPos(image, rfi, 2.5*strength*a1*a2, step*7, 1, index);
AddRfiPos(image, rfi, 2.0*strength*a1*a2, step*8, 1, index);
AddRfiPos(image, rfi, 1.8*strength*a1*a2, step*9, 1, index);
AddRfiPos(image, rfi, 1.6*strength*a1*a2, step*10, 1, index);
}
++index;
}
}
Logger::Debug << ".\n";
} else {
unsigned fStart = (unsigned) ((0.5 - length/2.0) * frequencyCount);
unsigned fEnd = (unsigned) ((0.5 + length/2.0) * frequencyCount);
AddBroadbandLinePos(image, rfi, 3.0*strength, step*1, 3, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 2.5*strength, step*2, 3, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 2.0*strength, step*3, 3, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 1.8*strength, step*4, 3, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 1.6*strength, step*5, 3, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 3.0*strength, step*6, 1, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 2.5*strength, step*7, 1, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 2.0*strength, step*8, 1, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 1.8*strength, step*9, 1, fStart, fEnd, shape);
AddBroadbandLinePos(image, rfi, 1.6*strength, step*10, 1, fStart, fEnd, shape);
}
}
bool screenshot(PluginManager::Manager<Trade::AbstractImageConverter>& manager, GL::AbstractFramebuffer& framebuffer, const PixelFormat format, const std::string& filename) {
Containers::Pointer<Trade::AbstractImageConverter> converter;
if(!(converter = manager.loadAndInstantiate("AnyImageConverter")))
return false;
Image2D image = framebuffer.read(framebuffer.viewport(), {format});
if(!converter->exportToFile(image, filename))
return false;
Debug{} << "DebugTools::screenshot(): saved a" << format << "image of size" << image.size() << "to" << filename;
return true;
}
Image2D TestSetGenerator::sampleRFIDistribution(unsigned width, unsigned height, double ig_over_rsq)
{
Image2D image = Image2D::MakeUnsetImage(width, height);
const double sigma = 1.0;
for(size_t f=0; f<height;++f) {
for(size_t t=0; t<width;++t) {
image.SetValue(t, f, Rand(Gaussian)*sigma + ig_over_rsq / RNG::Uniform());
}
}
return image;
}
void TestSetGenerator::AddBroadbandLine(Image2D& data, Mask2D& rfi, double lineStrength, size_t startTime, size_t duration, double frequencyRatio, double frequencyOffsetRatio)
{
size_t frequencyCount = data.Height();
unsigned fStart = (size_t) (frequencyOffsetRatio * frequencyCount);
unsigned fEnd = (size_t) ((frequencyOffsetRatio + frequencyRatio) * frequencyCount);
AddBroadbandLinePos(data, rfi, lineStrength, startTime, duration, fStart, fEnd, UniformShape);
}
void * Raw2D2Image2D(Raw2D &src,long long type)
{
PIXTYPE *data= new PIXTYPE[src.size()];
if (type==1)
{
unsigned char* datSrc = new unsigned char [src.size()];//(unsigned char*)(src.data);
//PIXTYPE *data= new PIXTYPE[src.GetLength()];
for (long long i=0;i<src.size();i++)
{
datSrc[i]=(unsigned char)src.getXY(i);
}
//void * ret= (void *)datSrc;
Image2D * ret = new Image2D(src.getXsize(),src.getYsize(),type);
memcpy(ret->data,datSrc,ret->GetLength());
unsigned char *dat =(unsigned char*)ret->data;
void *res =(void *)ret;
return res;
}
else if (type == 2)
{
unsigned short * datSrc = new unsigned short [src.size()];//(unsigned short *)(src.data);
//PIXTYPE *data= new PIXTYPE[src.GetLength()];
for (long long i=0;i<src.size();i++)
{
datSrc[i]=src.getXY(i);
}
void * ret=(void *)datSrc;
return datSrc;
}
else
{
float* datSrc = new float [src.size()]; //(short*)(src.data);
for (long long i=0;i<src.size();i++)
{
datSrc[i]=src.getXY(i);
}
void *ret =(void *)datSrc;
return datSrc;
}
}
void RecenterImage(Image2D &image)
{
IppStatus status;
Ipp32f minval = 0, maxval = 0;
status = ippiMinMax_32f_C1R(image.get_image2D(), image.get_stepsize(), image.get_ROIfull(),
&minval, &maxval);
status = ippiAddC_32f_C1IR(-minval, image.get_image2D(), image.get_stepsize(), image.get_ROIfull());
status = ippiMulC_32f_C1IR(100 / (maxval-minval), image.get_image2D(), image.get_stepsize(), image.get_ROIfull());
}
void TestSetGenerator::AddRfiPos(Image2D& data, Mask2D& rfi, double lineStrength, size_t startTime, size_t duration, unsigned frequencyPos)
{
for(size_t t=startTime;t<startTime+duration;++t) {
data.AddValue(t, frequencyPos, lineStrength);
if(lineStrength > 0)
rfi.SetValue(t, frequencyPos, true);
}
}
void TestSetGenerator::SubtractBackground(Image2D& image)
{
Mask2DPtr zero = Mask2D::CreateSetMaskPtr<false>(image.Width(), image.Height());
LocalFitMethod fittedImage;
fittedImage.SetToWeightedAverage(20, 40, 7.5, 15.0);
Image2DPtr imagePtr = Image2D::MakePtr(image);
TimeFrequencyData data(TimeFrequencyData::AmplitudePart, Polarization::StokesI, imagePtr);
data.SetGlobalMask(zero);
fittedImage.Initialize(data);
for(unsigned i=0;i<fittedImage.TaskCount();++i)
fittedImage.PerformFit(i);
image = Image2D::MakeFromDiff(image, *fittedImage.Background().GetSingleImage());
for(unsigned y=0;y<image.Height();++y) {
for(unsigned x=0;x<image.Width();++x) {
image.AddValue(x, y, 1.0);
}
}
}
void fill_data( Image2D& _data )
{
double* data;
CALuint pitch;
unsigned size;
data = (double*)_queue.mapMemObject(_data,pitch);
size = 2*_data.getWidth()*_data.getHeight();
for(unsigned i=0;i<size;i+=2) {
*(data + 0) = i+1;
*(data + 1) = i+1;
data+=2;
}
_queue.unmapMemObject(_data);
}
void TestSetGenerator::AddSlewedBroadbandToTestSet(Image2D& image, Mask2D& rfi, long double length, double strength, double slewrate, enum BroadbandShape shape)
{
size_t frequencyCount = image.Height();
unsigned step = image.Width()/11;
unsigned fStart = (unsigned) ((0.5 - length/2.0) * frequencyCount);
unsigned fEnd = (unsigned) ((0.5 + length/2.0) * frequencyCount);
AddSlewedBroadbandLinePos(image, rfi, 3.0*strength, slewrate, step*1, 3, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 2.5*strength, slewrate, step*2, 3, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 2.0*strength, slewrate, step*3, 3, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 1.8*strength, slewrate, step*4, 3, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 1.6*strength, slewrate, step*5, 3, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 3.0*strength, slewrate, step*6, 1, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 2.5*strength, slewrate, step*7, 1, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 2.0*strength, slewrate, step*8, 1, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 1.8*strength, slewrate, step*9, 1, fStart, fEnd, shape);
AddSlewedBroadbandLinePos(image, rfi, 1.6*strength, slewrate, step*10, 1, fStart, fEnd, shape);
}
void CubeMapTextureGLTest::image() {
CubeMapTexture texture;
texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), Data));
MAGNUM_VERIFY_NO_ERROR();
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
Image2D image = texture.image(CubeMapTexture::Coordinate::PositiveX, 0, {ColorFormat::RGBA, ColorType::UnsignedByte});
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector2i(2));
CORRADE_COMPARE_AS(
Containers::ArrayReference<const UnsignedByte>(image.data<UnsignedByte>(), image.pixelSize()*image.size().product()),
Containers::ArrayReference<const UnsignedByte>{Data}, TestSuite::Compare::Container);
#endif
}
void print_data( Image2D& _data )
{
double* data;
CALuint pitch;
unsigned size;
data = (double*)_queue.mapMemObject(_data,pitch);
size = 2*_data.getWidth()*_data.getHeight();
for(unsigned i=0;i<size;i+=2) {
std::cout << boost::format("(%.3f,%.3f)") % *data % *(data+1);
if( *data == *(data+1) ) std::cout << " OK\n";
else std::cout << " INVALID RESULT\n";
data+=2;
}
_queue.unmapMemObject(_data);
}
void ImageTile::AddBaseline(Image2D &dest, double sign)
{
// Add or subtract baseline
for(unsigned channel = 0;channel<_channelCount;++channel) {
for(unsigned scan = 0;scan<_scanCount;++scan) {
long double val = dest.Value(scan+_scanOffset, channel+_channelOffset);
val += sign * EvaluateBaselineFunction(scan, channel);
SetValueAt(dest, channel, scan, val);
}
}
}
Raw2D Image2D2Raw2D(Image2D &src)
{
PIXTYPE *data= new PIXTYPE[src.GetLength()];
if (src.PixelType==1)
{
unsigned char* datSrc = (unsigned char*)(src.data);
//PIXTYPE *data= new PIXTYPE[src.GetLength()];
for (int i=0;i<src.GetLength();i++)
{
data[i]=datSrc[i];
}
}
else if (src.PixelType == 2)
{
unsigned short * datSrc = (unsigned short *)(src.data);
//PIXTYPE *data= new PIXTYPE[src.GetLength()];
for (int i=0;i<src.GetLength();i++)
{
data[i]=datSrc[i];
}
}
else if (src.PixelType == 3 )
{
short* datSrc = (short*)(src.data);
for (int i=0;i<src.GetLength();i++)
{
data[i]=datSrc[i];
}
}
//src.Data=data;
Raw2D *ret=new Raw2D(src.width,src.height,data);
return *ret;
}
Image2D<unsigned char> Image2DGrey::down_sample() const
{
Image2D newImage (get_width() / 2, get_height() / 2);
for (int y=0; y < newImage.get_height();y++)
{
int oldY = y * 2;
for (int x=0; x<newImage.get_width();x++)
{
int oldX = x * 2;
int sample1 = get_pixel(oldX, oldY);
int sample2 = get_pixel(oldX + 1, oldY);
int sample3 = get_pixel(oldX, oldY + 1);
int sample4 = get_pixel(oldX + 1, oldY + 1);
newImage.set_pixel(x,y, (sample1 + sample2 + sample3 + sample4) / 4);
}
}
return newImage;
}
void TestSetGenerator::SetModelData(Image2D& image, Mask2D& rfi, unsigned sources)
{
class Model model;
if(sources>=5) {
model.AddSource(0.1,0.1,0.5);
model.AddSource(0.1,0.0,0.35);
model.AddSource(.101,0.001,0.45);
model.AddSource(1.0,0.0,1.0);
model.AddSource(4.0,3.0,0.9);
} else {
if(sources>=1)
model.AddSource(0.1,0.1,0.7);
if(sources>=2)
model.AddSource(0.1,0.0,0.5);
if(sources>=3)
model.AddSource(1.0,0.0,1.0);
}
WSRTObservatorium wsrt(size_t(0), size_t(1));
std::pair<TimeFrequencyData,TimeFrequencyMetaDataCPtr> data =
model.SimulateObservation(wsrt, 0.05, 0.05, 0, 1);
image = *data.first.GetRealPart();
rfi = Mask2D::MakeSetMask<false>(image.Width(), image.Height());
}
Event CommandQueue::enqueueUnmap(const Image2D& image, void *mappedPtr,
const Epic::Core::Array<Event>& eventWaitList) const
{
Event ret;
cl_int err = 0;
Array<cl_event> events = eventArrayToCLEventArray(eventWaitList);
err = clEnqueueUnmapMemObject(queueHandle(), image.imageHandle(), mappedPtr,
events.count(), events.data(), ret.eventPointer());
EPIC_OPENCL_CHECK_ERROR(err)
return ret;
}
void TestSetGenerator::AddBroadbandLinePos(Image2D& data, Mask2D& rfi, double lineStrength, size_t startTime, size_t duration, unsigned frequencyStart, double frequencyEnd, enum BroadbandShape shape)
{
const double s = (frequencyEnd-frequencyStart);
for(size_t f=frequencyStart;f<frequencyEnd;++f) {
// x will run from -1 to 1
const double x = (double) ((f-frequencyStart)*2)/s-1.0;
double factor = shapeLevel(shape, x);
for(size_t t=startTime;t<startTime+duration;++t) {
data.AddValue(t, f, lineStrength * factor);
if(lineStrength > 0.0)
rfi.SetValue(t, f, true);
}
}
}
void TestSetGenerator::AddSlewedBroadbandLinePos(Image2D& data, Mask2D& rfi, double lineStrength, double slewrate, size_t startTime, size_t duration, unsigned frequencyStart, double frequencyEnd, enum BroadbandShape shape)
{
const double s = (frequencyEnd-frequencyStart);
for(size_t f=frequencyStart;f<frequencyEnd;++f) {
// x will run from -1 to 1
const double x = (double) ((f-frequencyStart)*2)/s-1.0;
double factor = shapeLevel(shape, x);
double slew = slewrate * (double) f;
size_t slewInt = (size_t) slew;
double slewRest = slew - slewInt;
data.AddValue(startTime+slewInt, f, lineStrength * factor * (1.0 - slewRest));
if(lineStrength > 0.0)
rfi.SetValue(startTime+slewInt, f, true);
for(size_t t=startTime+1;t<startTime+duration;++t) {
data.AddValue(t+slewInt, f, lineStrength * factor);
if(lineStrength > 0.0)
rfi.SetValue(t+slewInt, f, true);
}
data.AddValue(startTime+duration+slewInt, f, lineStrength * factor * slewRest);
if(lineStrength > 0.0)
rfi.SetValue(startTime+duration+slewInt, f, true);
}
}
Event CommandQueue::enqueueWriteImage(const Image2D& image, bool blockingRead, const size_t origin[2], const size_t region[2],
size_t rowPitch, void *pointer, const Epic::Core::Array<Event>& eventWaitList) const
{
Event ret;
cl_int err = 0;
Array<cl_event> events = eventArrayToCLEventArray(eventWaitList);
const size_t orig[3] = { origin[0], origin[1], 0};
const size_t regn[3] = { region[0], region[1], 1};
err = clEnqueueWriteImage(queueHandle(), image.imageHandle(), blockingRead, orig, regn, rowPitch, 0, pointer,
events.count(), events.data(), ret.eventPointer());
EPIC_OPENCL_CHECK_ERROR(err)
return ret;
}
void TestSetGenerator::AddVarBroadbandToTestSet(Image2D& image, Mask2D& rfi)
{
// The "randomness" should be reproducable randomness, so calling
// the random number generator to generate the numbers is not a good
// idea.
unsigned step = image.Width()/11;
AddBroadbandLine(image, rfi, 3.0, step*1, 3, 0.937071,0.0185952);
AddBroadbandLine(image, rfi, 2.5, step*2, 3, 0.638442,0.327689);
AddBroadbandLine(image, rfi, 2.0, step*3, 3, 0.859308,0.0211675);
AddBroadbandLine(image, rfi, 1.8, step*4, 3, 0.418327,0.324842);
AddBroadbandLine(image, rfi, 1.6, step*5, 3, 0.842374,0.105613);
AddBroadbandLine(image, rfi, 3.0, step*6, 1, 0.704607,0.163653);
AddBroadbandLine(image, rfi, 2.5, step*7, 1, 0.777955,0.0925143);
AddBroadbandLine(image, rfi, 2.0, step*8, 1, 0.288418,0.222322);
AddBroadbandLine(image, rfi, 1.8, step*9, 1, 0.892462,0.0381083);
AddBroadbandLine(image, rfi, 1.6, step*10, 1, 0.444377,0.240526);
}
void Mouse::Draw(Image2D& mouseImage, int textureWidth, int textureHeight)
{
if(instance->enableCustomMouseCursor == true)
{
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, instance->screenWidth, instance->screenHeight, 0, 0, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
mouseImage.Draw(this->cursorx, this->cursory, textureWidth, textureHeight, false);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
instance->CursorFramed();
}
void PngFile::Save(const Image2D &image, const ColorMap &colorMap) throw(IOException)
{
long double normalizeFactor = image.GetMaxMinNormalizationFactor();
png_bytep *row_pointers = RowPointers();
for(unsigned long y=0;y<image.Height();++y) {
for(unsigned long x=0;x<image.Width();++x) {
int xa = x * PixelSize();
row_pointers[y][xa]=colorMap.ValueToColorR(image.Value(x, y) * normalizeFactor);
row_pointers[y][xa+1]=colorMap.ValueToColorG(image.Value(x, y) * normalizeFactor);
row_pointers[y][xa+2]=colorMap.ValueToColorB(image.Value(x, y) * normalizeFactor);
row_pointers[y][xa+3]=colorMap.ValueToColorA(image.Value(x, y) * normalizeFactor);
}
}
}
void AbstractFramebuffer::read(const Range2Di& rectangle, Image2D& image) {
bindInternal(FramebufferTarget::Read);
/* Reallocate only if needed */
const std::size_t dataSize = Implementation::imageDataSizeFor(image, rectangle.size());
Containers::Array<char> data{image.release()};
if(data.size() < dataSize)
data = Containers::Array<char>{dataSize};
#ifndef MAGNUM_TARGET_GLES2
Buffer::unbindInternal(Buffer::TargetHint::PixelPack);
#endif
image.storage().applyPack();
(Context::current().state().framebuffer->readImplementation)(rectangle, image.format(), image.type(), data.size(), data
#ifdef MAGNUM_TARGET_GLES2
+ Implementation::pixelStorageSkipOffsetFor(image, rectangle.size())
#endif
);
image.setData(image.storage(), image.format(), image.type(), rectangle.size(), std::move(data));
}
