bool TextLocation::getBoundingBox(const IplImage* src, int &clusterNum, CvRect &box) {
vector<CvRect> rects(0);
vector<CvPoint> centers(0);
maxNumLimitedConnectComponet(src, kboxMaxNum, rects, centers);
removeSmallRect(rects, centers);
removePillarRect(rects, centers);
if (centers.size() == 0) {
return false;
} else {
// no clustering
clusterNum = 1;
getUnitedRects(rects, box);
return true;
}
}
/*
Get the region at an index. Use find(int) to get the index from an id.
*/
QRegion QWSRegionManager::region( int idx )
{
QRegion r;
if ( regIdx[idx].numRects )
r.setRects( rects(regIdx[idx].data), regIdx[idx].numRects );
return r;
}
/*
Commit the region table to shared memory.
The region table is not copied to shared memory every time it is
modified as this would lead to a great deal of overhead when the server
is calculating new regions. Once all regions have been modified, commit()
should be called to set the new region table in shared memory.
*/
void QWSRegionManager::commit()
{
if ( client ) return;
QWSDisplay::grab( TRUE );
// copy region rects first
int numRects;
int offset = 0;
QRect *r = rects(0);
for ( int idx = 0; idx < regHdr->maxRegions; idx++ ) {
if ( regIdx[idx].id != -1 ) {
numRects = regIdx[idx].numRects;
if ( numRects ) {
if ( offset + numRects > regHdr->maxRects ) {
// What do we do? Resize the shared memory?
qFatal( "Too many client rects" );
}
regIdx[idx].data = offset;
memcpy( r, regions[idx]->rects().data(),
numRects * sizeof(QRect) );
r += numRects;
offset += numRects;
}
}
}
// now copy region header and index
memcpy( data, regHdr, sizeof(QWSRegionHeader) );
memcpy( data + sizeof(QWSRegionHeader),
(unsigned char *)regIdx,
regHdr->maxRegions * sizeof(QWSRegionIndex) );
QWSDisplay::ungrab();
}
void onDelayedSetup() override {
SkRandom rand;
SkAutoTMalloc<SkRect> rects(NUM_QUERY_RECTS);
for (int i = 0; i < NUM_QUERY_RECTS; ++i) {
rects[i] = fProc(rand, i, NUM_QUERY_RECTS);
}
fTree.insert(rects.get(), NUM_QUERY_RECTS);
}
/*!\func
* draw edge
* \params no
* \return no
*/
void EdgeAssotiation::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
if (!sourceNode() || !destNode())
return;
QColor color (Qt::black);
switch (getState()) {
case OFF:
color = Qt::gray;
break;
case OK:
color = Qt::green;
break;
case WARNING:
default:
color = Qt::red;
}
painter->setPen(QPen(color, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
float width = destNode()->boundingRect().width();
float height = destNode()->boundingRect().height();
QRectF rect(destNode()->pos().x() , destNode()->pos().y(), width, height);
width = sourceNode()->boundingRect().width();
height = sourceNode()->boundingRect().height();
QRectF rects(sourceNode()->pos().x(), sourceNode()->pos().y(), width, height);
painter->setBrush(color);
painter->drawLine(destPoint, middlePoint);
painter->drawLine(middlePoint, sourcePoint);
painter->setPen(Qt::SolidLine);
if(rect.contains(middlePoint))
{//arrow enter in node by left or right
int sign = destPoint.x() > sourcePoint.x() ? 1 : -1;
//QMessageBox::information(0,"","arrow enter in node by left or right");
QPointF destArrowP1 = QPointF(middlePoint.x() - sign*rect.width()/2, middlePoint.y());
QPointF destArrowP2 = QPointF(middlePoint.x() - sign*(rect.width()/2 + arrowSize), middlePoint.y()-arrowSize/2);
QPointF destArrowP3 = QPointF(middlePoint.x() - sign*(rect.width()/2 + arrowSize), middlePoint.y()+arrowSize/2);
painter->setBrush(color);
painter->drawPolygon(QPolygonF() << destArrowP3 << destArrowP1 << destArrowP2);
}
else
{//arrow enter in node by top or bottom
int sign = destPoint.y() > sourcePoint.y() ? 1 : -1;
//QMessageBox::information(0,"","arrow enter in node by left or right");
QPointF destArrowP1 = QPointF(destPoint.x(), destPoint.y()-sign*rect.height()/2);
QPointF destArrowP2 = QPointF(destPoint.x()-arrowSize/2, destPoint.y() - sign*(rect.height()/2 + arrowSize));
QPointF destArrowP3 = QPointF(destPoint.x()+arrowSize/2, destPoint.y() - sign*(rect.height()/2 + arrowSize));
painter->setBrush(color);
painter->drawPolygon(QPolygonF() << destArrowP3 << destArrowP1 << destArrowP2);
}
if(rects.contains(middlePoint))
name->setPos((sourcePoint + destPoint)/2);
else
{
if(sourcePoint.x() < destPoint.x())
name->setPos(sourcePoint + QPointF(sourceNode()->boundingRect().width()/2,-name->boundingRect().height()));
else
name->setPos(sourcePoint + QPointF(-name->boundingRect().width()-sourceNode()->boundingRect().width()/2,-name->boundingRect().height()));
}
}
// Constructeur par défault
Selectable::Selectable() : Entity(),
m_isSelected(false),
m_selectTag(m_animationManager->addAnimation(true, true, 0.1f))
{
std::vector<sf::Rect<int> > rects(1, sf::Rect<int>(0,0, 36,36));
m_animationManager->addAnim(m_selectTag, "media/image/select_tag.png", rects, "hold");
m_selectTag->setAnim("hold", true);
m_selectTag->setOrigin(18,18);
}
Vector<FloatRect> NinePieceImage::computeNonIntrinsicRects(const Vector<FloatRect>& intrinsicRects, const LayoutBoxExtent& slices)
{
Vector<FloatRect> rects(MaxPiece);
for (ImagePiece piece = MinPiece; piece < MaxPiece; ++piece) {
if (isEmptyPieceRect(piece, slices))
continue;
rects[piece] = FloatRect(FloatPoint(), intrinsicRects[piece].size());
}
return rects;
}
void onDraw(int loops, SkCanvas* canvas) override {
SkRandom rand;
SkAutoTMalloc<SkRect> rects(NUM_BUILD_RECTS);
for (int i = 0; i < NUM_BUILD_RECTS; ++i) {
rects[i] = fProc(rand, i, NUM_BUILD_RECTS);
}
for (int i = 0; i < loops; ++i) {
SkRTree tree;
tree.insert(rects.get(), NUM_BUILD_RECTS);
SkASSERT(rects != nullptr); // It'd break this bench if the tree took ownership of rects.
}
}
void maskRenderWidget::paintEvent(QPaintEvent *e)
{
QImage * device = &pimpl_->foreground_;
if (Impl::Rubber == pimpl_->shape_)
device = &pimpl_->band_buffer_;
pimpl_->paintOnDevice(device);
QPainter painter(this);
QVector<QRect> rects(e->region().rects());
for (int i = 0; i < rects.count(); ++i)
{
QRect r = rects[i];
painter.drawImage(r, *device, r);
}
}
void AbstractBox::paintEvent(QPaintEvent *e) {
Painter p(this);
auto clip = e->rect();
auto paintTopRounded = clip.intersects(QRect(0, 0, width(), st::boxRadius));
auto paintBottomRounded = clip.intersects(QRect(0, height() - st::boxRadius, width(), st::boxRadius));
if (paintTopRounded || paintBottomRounded) {
auto parts = RectPart::None | 0;
if (paintTopRounded) parts |= RectPart::FullTop;
if (paintBottomRounded) parts |= RectPart::FullBottom;
App::roundRect(p, rect(), st::boxBg, BoxCorners, nullptr, parts);
}
auto other = e->region().intersected(QRect(0, st::boxRadius, width(), height() - 2 * st::boxRadius));
if (!other.isEmpty()) {
for (auto rect : other.rects()) {
p.fillRect(rect, st::boxBg);
}
}
if (!_additionalTitle.isEmpty() && clip.intersects(QRect(0, 0, width(), titleHeight()))) {
paintAdditionalTitle(p);
}
}
Vector<FloatRect> NinePieceImage::computeIntrinsicRects(const FloatRect& outer, const LayoutBoxExtent& slices, float deviceScaleFactor)
{
FloatRect inner = outer;
inner.move(slices.left(), slices.top());
inner.contract(slices.left() + slices.right(), slices.top() + slices.bottom());
ASSERT(outer.contains(inner));
Vector<FloatRect> rects(MaxPiece);
rects[TopLeftPiece] = snapRectToDevicePixels(outer.x(), outer.y(), slices.left(), slices.top(), deviceScaleFactor);
rects[BottomLeftPiece] = snapRectToDevicePixels(outer.x(), inner.maxY(), slices.left(), slices.bottom(), deviceScaleFactor);
rects[LeftPiece] = snapRectToDevicePixels(outer.x(), inner.y(), slices.left(), inner.height(), deviceScaleFactor);
rects[TopRightPiece] = snapRectToDevicePixels(inner.maxX(), outer.y(), slices.right(), slices.top(), deviceScaleFactor);
rects[BottomRightPiece] = snapRectToDevicePixels(inner.maxX(), inner.maxY(), slices.right(), slices.bottom(), deviceScaleFactor);
rects[RightPiece] = snapRectToDevicePixels(inner.maxX(), inner.y(), slices.right(), inner.height(), deviceScaleFactor);
rects[TopPiece] = snapRectToDevicePixels(inner.x(), outer.y(), inner.width(), slices.top(), deviceScaleFactor);
rects[BottomPiece] = snapRectToDevicePixels(inner.x(), inner.maxY(), inner.width(), slices.bottom(), deviceScaleFactor);
rects[MiddlePiece] = snapRectToDevicePixels(inner.x(), inner.y(), inner.width(), inner.height(), deviceScaleFactor);
return rects;
}
DEF_TEST(RTree, reporter) {
int expectedDepthMin = -1;
int tmp = NUM_RECTS;
while (tmp > 0) {
tmp -= static_cast<int>(pow(static_cast<double>(SkRTree::kMaxChildren),
static_cast<double>(expectedDepthMin + 1)));
++expectedDepthMin;
}
int expectedDepthMax = -1;
tmp = NUM_RECTS;
while (tmp > 0) {
tmp -= static_cast<int>(pow(static_cast<double>(SkRTree::kMinChildren),
static_cast<double>(expectedDepthMax + 1)));
++expectedDepthMax;
}
SkRandom rand;
SkAutoTMalloc<SkRect> rects(NUM_RECTS);
for (size_t i = 0; i < NUM_ITERATIONS; ++i) {
SkRTree rtree;
REPORTER_ASSERT(reporter, 0 == rtree.getCount());
for (int j = 0; j < NUM_RECTS; j++) {
rects[j] = random_rect(rand);
}
rtree.insert(rects.get(), NUM_RECTS);
SkASSERT(rects); // SkRTree doesn't take ownership of rects.
run_queries(reporter, rand, rects, rtree);
REPORTER_ASSERT(reporter, NUM_RECTS == rtree.getCount());
REPORTER_ASSERT(reporter, expectedDepthMin <= rtree.getDepth() &&
expectedDepthMax >= rtree.getDepth());
}
}
Error EditorTextureImportPlugin::import2(const String& p_path, const Ref<ResourceImportMetadata>& p_from,EditorExportPlatform::ImageCompression p_compr, bool p_external){
ERR_FAIL_COND_V(p_from->get_source_count()==0,ERR_INVALID_PARAMETER);
Ref<ResourceImportMetadata> from=p_from;
Ref<ImageTexture> texture;
Vector<Ref<AtlasTexture> > atlases;
bool atlas = from->get_option("atlas");
int flags=from->get_option("flags");
uint32_t tex_flags=0;
if (flags&EditorTextureImportPlugin::IMAGE_FLAG_REPEAT)
tex_flags|=Texture::FLAG_REPEAT;
if (flags&EditorTextureImportPlugin::IMAGE_FLAG_FILTER)
tex_flags|=Texture::FLAG_FILTER;
if (!(flags&EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS))
tex_flags|=Texture::FLAG_MIPMAPS;
int shrink=1;
if (from->has_option("shrink"))
shrink=from->get_option("shrink");
if (atlas) {
//prepare atlas!
Vector< Image > sources;
bool alpha=false;
bool crop = from->get_option("crop");
EditorProgress ep("make_atlas","Build Atlas For: "+p_path.get_file(),from->get_source_count()+3);
print_line("sources: "+itos(from->get_source_count()));
for(int i=0;i<from->get_source_count();i++) {
String path = EditorImportPlugin::expand_source_path(from->get_source_path(i));
ep.step("Loading Image: "+path,i);
print_line("source path: "+path);
Image src;
Error err = ImageLoader::load_image(path,&src);
if (err) {
EditorNode::add_io_error("Couldn't load image: "+path);
return err;
}
if (src.detect_alpha())
alpha=true;
sources.push_back(src);
}
ep.step("Converting Images",sources.size());
for(int i=0;i<sources.size();i++) {
if (alpha) {
sources[i].convert(Image::FORMAT_RGBA);
} else {
sources[i].convert(Image::FORMAT_RGB);
}
}
//texturepacker is not really good for optimizing, so..
//will at some point likely replace with my own
//first, will find the nearest to a square packing
int border=1;
Vector<Size2i> src_sizes;
Vector<Rect2> crops;
ep.step("Cropping Images",sources.size()+1);
for(int j=0;j<sources.size();j++) {
Size2i s;
if (crop) {
Rect2 crop = sources[j].get_used_rect();
print_line("CROP: "+crop);
s=crop.size;
crops.push_back(crop);
} else {
s=Size2i(sources[j].get_width(),sources[j].get_height());
}
s+=Size2i(border*2,border*2);
src_sizes.push_back(s); //add a line to constraint width
}
Vector<Point2i> dst_positions;
Size2i dst_size;
EditorAtlas::fit(src_sizes,dst_positions,dst_size);
print_line("size that workeD: "+itos(dst_size.width)+","+itos(dst_size.height));
ep.step("Blitting Images",sources.size()+2);
Image atlas;
atlas.create(nearest_power_of_2(dst_size.width),nearest_power_of_2(dst_size.height),0,alpha?Image::FORMAT_RGBA:Image::FORMAT_RGB);
for(int i=0;i<sources.size();i++) {
int x=dst_positions[i].x;
int y=dst_positions[i].y;
Ref<AtlasTexture> at = memnew( AtlasTexture );
Size2 sz = Size2(sources[i].get_width(),sources[i].get_height());
if (crop && sz!=crops[i].size) {
Rect2 rect = crops[i];
rect.size=sz-rect.size;
at->set_region(Rect2(x+border,y+border,crops[i].size.width,crops[i].size.height));
at->set_margin(rect);
atlas.blit_rect(sources[i],crops[i],Point2(x+border,y+border));
} else {
at->set_region(Rect2(x+border,y+border,sz.x,sz.y));
atlas.blit_rect(sources[i],Rect2(0,0,sources[i].get_width(),sources[i].get_height()),Point2(x+border,y+border));
}
String apath = p_path.get_base_dir().plus_file(from->get_source_path(i).get_file().basename()+".atex");
print_line("Atlas Tex: "+apath);
at->set_path(apath);
atlases.push_back(at);
}
if (ResourceCache::has(p_path)) {
texture = Ref<ImageTexture> ( ResourceCache::get(p_path)->cast_to<ImageTexture>() );
} else {
texture = Ref<ImageTexture>( memnew( ImageTexture ) );
}
texture->create_from_image(atlas,tex_flags);
} else {
ERR_FAIL_COND_V(from->get_source_count()!=1,ERR_INVALID_PARAMETER);
String src_path = EditorImportPlugin::expand_source_path(from->get_source_path(0));
if (ResourceCache::has(p_path)) {
Resource *r = ResourceCache::get(p_path);
texture = Ref<ImageTexture> ( r->cast_to<ImageTexture>() );
Image img;
Error err = img.load(src_path);
ERR_FAIL_COND_V(err!=OK,ERR_CANT_OPEN);
texture->create_from_image(img);
} else {
texture=ResourceLoader::load(src_path,"ImageTexture");
}
ERR_FAIL_COND_V(texture.is_null(),ERR_CANT_OPEN);
if (!p_external)
from->set_source_md5(0,FileAccess::get_md5(src_path));
}
int format=from->get_option("format");
float quality=from->get_option("quality");
if (!p_external) {
from->set_editor(get_name());
texture->set_path(p_path);
texture->set_import_metadata(from);
}
if (atlas) {
if (p_external) {
//used by exporter
Array rects(true);
for(int i=0;i<atlases.size();i++) {
rects.push_back(atlases[i]->get_region());
rects.push_back(atlases[i]->get_margin());
}
from->set_option("rects",rects);
} else {
//used by importer
for(int i=0;i<atlases.size();i++) {
String apath = atlases[i]->get_path();
atlases[i]->set_atlas(texture);
Error err = ResourceSaver::save(apath,atlases[i]);
if (err) {
EditorNode::add_io_error("Couldn't save atlas image: "+apath);
return err;
}
from->set_source_md5(i,FileAccess::get_md5(apath));
}
}
}
if (format==IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS || format==IMAGE_FORMAT_COMPRESS_DISK_LOSSY) {
Image image=texture->get_data();
ERR_FAIL_COND_V(image.empty(),ERR_INVALID_DATA);
bool has_alpha=image.detect_alpha();
if (!has_alpha && image.get_format()==Image::FORMAT_RGBA) {
image.convert(Image::FORMAT_RGB);
}
if (image.get_format()==Image::FORMAT_RGBA && flags&IMAGE_FLAG_FIX_BORDER_ALPHA) {
image.fix_alpha_edges();
}
if (shrink>1) {
int orig_w=image.get_width();
int orig_h=image.get_height();
image.resize(orig_w/shrink,orig_h/shrink);
texture->create_from_image(image,tex_flags);
texture->set_size_override(Size2(orig_w,orig_h));
} else {
texture->create_from_image(image,tex_flags);
}
if (format==IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS) {
texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSLESS);
} else {
texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSY);
}
texture->set_lossy_storage_quality(quality);
Error err = ResourceSaver::save(p_path,texture);
if (err!=OK) {
EditorNode::add_io_error("Couldn't save converted texture: "+p_path);
return err;
}
} else {
print_line("compress...");
Image image=texture->get_data();
ERR_FAIL_COND_V(image.empty(),ERR_INVALID_DATA);
bool has_alpha=image.detect_alpha();
if (!has_alpha && image.get_format()==Image::FORMAT_RGBA) {
image.convert(Image::FORMAT_RGB);
}
if (image.get_format()==Image::FORMAT_RGBA && flags&IMAGE_FLAG_FIX_BORDER_ALPHA) {
image.fix_alpha_edges();
}
int orig_w=image.get_width();
int orig_h=image.get_height();
if (shrink>1) {
image.resize(orig_w/shrink,orig_h/shrink);
texture->create_from_image(image,tex_flags);
texture->set_size_override(Size2(orig_w,orig_h));
}
if (!(flags&IMAGE_FLAG_NO_MIPMAPS)) {
image.generate_mipmaps();
}
if (format!=IMAGE_FORMAT_UNCOMPRESSED) {
compress_image(p_compr,image,flags&IMAGE_FLAG_COMPRESS_EXTRA);
}
print_line("COMPRESSED TO: "+itos(image.get_format()));
texture->create_from_image(image,tex_flags);
if (shrink>1) {
texture->set_size_override(Size2(orig_w,orig_h));
}
uint32_t save_flags=ResourceSaver::FLAG_COMPRESS;
Error err = ResourceSaver::save(p_path,texture,save_flags);
if (err!=OK) {
EditorNode::add_io_error("Couldn't save converted texture: "+p_path);
return err;
}
}
return OK;
}
template <class T> void ossimWatermarkFilter::fill(T /* dummy */)
{
const ossimIrect TILE_RECT = theTile->getImageRectangle();
// We will only fill data within the input bounding rect.
const ossimIrect CLIPPED_TILE_RECT =
TILE_RECT.clipToRect(theInputBoundingRect);
// Get the bounding rectangles.
vector<ossimIrect> rects(0);
getIntersectingRects(rects);
if (rects.size() == 0)
{
return;
}
//---
// Have watermark rectangles that intersect this tile so we need to process.
//---
ossim_uint32 band = 0;
ossim_float64 inputPixWeight = 1.0 - theWatermarkWeight;
// Get a pointers to the watermark buffers (wmBuf) and nulls wn.
T** wmBuf = new T*[theWatermarkNumberOfBands];
for (band = 0; band < theWatermarkNumberOfBands; ++band)
{
wmBuf[band] = static_cast<T*>(theWatermark->getBuf(band));
}
// Get a pointers to the output tile buffers and nulls in.
T** otBuf = new T*[theInputNumberOfBands];
for (band = 0; band < theInputNumberOfBands; ++band)
{
otBuf[band] = static_cast<T*>(theTile->getBuf(band));
}
// Get the width of the buffers for indexing.
ossim_int32 wmWidth = static_cast<ossim_int32>(theWatermark->getWidth());
ossim_int32 otWidth = static_cast<ossim_int32>(theTile->getWidth());
const ossim_float64* wmNull = theWatermark->getNullPix();
const ossim_float64* otMin = theTile->getMinPix();
const ossim_float64* otMax = theTile->getMaxPix();
const ossim_float64* otNull = theTile->getNullPix();
// Control loop through intersecting rectangles.
vector<ossimIrect>::const_iterator i = rects.begin();
while (i != rects.end())
{
if ( (*i).intersects(CLIPPED_TILE_RECT) )
{
//---
// This is the rectangle we want to fill relative to requesting
// image space.
//---
const ossimIrect CLIPPED_WATERMARRK_RECT =
(*i).clipToRect(CLIPPED_TILE_RECT);
ossim_int32 clipHeight = CLIPPED_WATERMARRK_RECT.height();
ossim_int32 clipWidth = CLIPPED_WATERMARRK_RECT.width();
// Compute the starting offset into the wmBuf and otBuf.
ossim_int32 wmOffset =
(CLIPPED_WATERMARRK_RECT.ul().y - (*i).ul().y) * wmWidth +
CLIPPED_WATERMARRK_RECT.ul().x - (*i).ul().x;
ossim_int32 otOffset =
(CLIPPED_WATERMARRK_RECT.ul().y - TILE_RECT.ul().y)* otWidth +
CLIPPED_WATERMARRK_RECT.ul().x - TILE_RECT.ul().x;
// Line loop...
for (ossim_int32 line = 0; line < clipHeight; ++line)
{
// Sample loop...
for (ossim_int32 sample = 0; sample < clipWidth; ++sample)
{
// Output band control loop until all output bands are filled.
ossim_uint32 otBand = 0;
while (otBand < theInputNumberOfBands)
{
// Band loop through the watermark.
for (ossim_uint32 wmBand = 0;
wmBand < theWatermarkNumberOfBands;
++wmBand)
{
if (wmBuf[wmBand][wmOffset+sample] != wmNull[wmBand])
{
// Apply the weight to the input pixel.
ossim_float64 p1 =
(otBuf[otBand][otOffset+sample] != otNull[otBand]) ?
otBuf[otBand][otOffset+sample] * inputPixWeight :
0.0;
// Apply the Weight to the watermark pixel.
ossim_float64 p2 =
wmBuf[wmBand][wmOffset+sample]*theWatermarkWeight;
// Add them up.
ossim_float64 p3 = p1 + p2;
// Cast to output type with range checking.
otBuf[otBand][otOffset+sample] = static_cast<T>(
( (p3 >= otMin[otBand]) ?
(p3 < otMax[otBand] ? p3 : otMax[otBand]) :
otNull[otBand]) );
}
++otBand;
// We stop when we reach here. All output bands filled.
if (otBand == theInputNumberOfBands)
{
break;
}
} // End of band through watermark.
} // End of outer band loop.
} // End of sample loop.
wmOffset += wmWidth;
otOffset += otWidth;
} // End of line loop.
} // End "if ( (*i).intersects(TILE_RECT) )"
++i; // Go to next rectangle to fill if any.
} // End of "while (i != rects.end())"
// Clean up.
delete [] wmBuf;
delete [] otBuf;
theTile->validate();
}
void ColorPalette::drawTimePannel(QPainter &painter)
{
painter.save();
QPen pen;
pen.setColor(QColor(0,0,0));
pen.setWidthF(1);
painter.setPen(pen);
painter.setFont(QFont(QObject::tr("WenQuanYi"),8));
float x = draw_erae_.left();
float y = draw_erae_.top();
// float width = painter.fontMetrics().width("Time");
// painter.drawText(QRectF(x - 5,y - 15,width,15),Qt::AlignCenter|Qt::AlignTop,"Time");
float diff = (draw_erae_.width())/1020;
QRgb srgb = QRgb(0x660000);
int sred = qRed(srgb);
int k = 1020;
QRectF rect;
while(k >0)
{
rect = QRectF(draw_erae_.left() + k * diff, draw_erae_.top(),diff,draw_erae_.height() * 0.25);
//painter.drawRect(rect);
if (k < 153)
{
painter.fillRect(rect, QBrush(QColor(sred + k, 0, 0)));
}
else if (k < 408 && k >= 153)
{
painter.fillRect(rect, QBrush(QColor(255, k - 153, 0)));
}
else if ( k < 663 && k >= 408)
{
painter.fillRect(rect, QBrush(QColor(255 - (k - 408), 255, 0)));
}
else if (k < 918 && k>= 663)
{
painter.fillRect(rect, QBrush(QColor(0, 255 - (k - 663), k - 663)));
}
else
{
painter.fillRect(rect, QBrush(QColor(0,0,255- (k - 918))));
}
k--;
}
QRectF rects(draw_erae_.left(),draw_erae_.top(),draw_erae_.width(),draw_erae_.height()*0.25);
painter.drawRect(rects);
int partion = 1;
int datastep = 0;
if (days_ <= 7) //如果总天数小于等于7天则分成4份，否则分成6份
{
partion = 4;
datastep = 2;
}
else
{
partion = 6;
datastep = days_ / partion;
}
float step = draw_erae_.width() / partion;
QString tempday = "";
float line = 0;
while(line < draw_erae_.width())
{
if (partion == 4)
{
painter.drawLine(x + line,y,x + line,y + draw_erae_.height()*0.25);
tempday = start_date_.toString("MM/dd");
float width = painter.fontMetrics().width(tempday);
float height = painter.fontMetrics().height();
painter.drawText(QRectF(x+line-width/2,y+draw_erae_.height()*0.25+4,width,height),Qt::AlignCenter,tempday);
start_date_ = start_date_.addDays(datastep);
line += step;
}
else
{
line += step;
if (line < draw_erae_.width())
{
painter.drawLine(x + line,y,x + line,y + draw_erae_.height()*0.25);
tempday = start_date_.toString("MM/dd");
float width = painter.fontMetrics().width(tempday);
float height = painter.fontMetrics().height();
painter.drawText(QRectF(x+line-width/2,y+draw_erae_.height()*0.25+4,width,height),Qt::AlignCenter,tempday);
start_date_ = start_date_.addDays(datastep);
}
}
}
painter.restore();
}
std::multimap<MyVector2, MyVector2> AlgoMaxRects::pack(const std::vector< MyVector2> &temp, const MyVector2 &size, bool &fine)
{
std::list<MyBox> freeBoxes;
freeBoxes.push_back(MyBox(0,0,size.x,size.y));
std::list<MyVector2> rects(temp.begin(), temp.end());
std::multimap<MyVector2, MyVector2> boxes;
while (!rects.empty())
{
int min = std::max(size.x,size.y);
std::list<MyVector2>::iterator minIterRects = rects.end();
std::list<MyBox>::iterator minIterFreeBoxes = freeBoxes.end();
for (auto iterRects = rects.begin(); iterRects != rects.end(); iterRects++)
{
for (auto iterFreeBoxes = freeBoxes.begin(); iterFreeBoxes != freeBoxes.end(); iterFreeBoxes++)
{
int distance = std::min(iterFreeBoxes->size.y - iterRects->y, iterFreeBoxes->size.x - iterRects->x);
if (distance < 0)
{
//std::cout<<"The box "<<iterFreeBoxes->pos<<" with a size "<<iterFreeBoxes->size<<" is too small for "<<*iterRects<<std::endl;
continue;
}
if (distance < min)
{
//std::cout<<"The box "<<iterFreeBoxes->pos<<" with a size "<<iterFreeBoxes->size<<" is ok for "<<*iterRects<<std::endl;
min = distance;
minIterRects = iterRects;
minIterFreeBoxes = iterFreeBoxes;
}
}
}
if (minIterRects == rects.end() || minIterFreeBoxes == freeBoxes.end())
{
return std::multimap<MyVector2, MyVector2>();
}
//std::cout<<"I am placing the box "<<*minIterRects<<" into the position "<<minIterFreeBoxes->pos<<std::endl;
//std::cout<<minIterFreeBoxes->pos<<std::endl;
MyBox insertedBox = MyBox(minIterFreeBoxes->pos,*minIterRects);
boxes.insert(std::make_pair(*minIterRects,minIterFreeBoxes->pos));
freeBoxes.push_front(MyBox(
MyVector2(
minIterFreeBoxes->pos.x + minIterRects->x,
minIterFreeBoxes->pos.y + 0),
MyVector2(
minIterFreeBoxes->size.x - minIterRects->x,
minIterFreeBoxes->size.y)
));
freeBoxes.push_front(MyBox(
MyVector2(
minIterFreeBoxes->pos.x + 0,
minIterFreeBoxes->pos.y + minIterRects->y),
MyVector2(
minIterFreeBoxes->size.x,
minIterFreeBoxes->size.y - minIterRects->y)
));
freeBoxes.erase(minIterFreeBoxes);
MyVector2 a1 = insertedBox.pos;
//MyVector2 a2 = MyVector2(insertedBox.pos.x + insertedBox.size.x,insertedBox.pos.y);
MyVector2 a3 = MyVector2(insertedBox.pos.x + insertedBox.size.x,insertedBox.pos.y + insertedBox.size.y);
//MyVector2 a4 = MyVector2(insertedBox.pos.x ,insertedBox.pos.y + insertedBox.size.y);
for (auto iterFreeBoxes = freeBoxes.begin(); iterFreeBoxes != freeBoxes.end();)
{
assert(iterFreeBoxes != freeBoxes.end());
//assert(!(iterFreeBoxes->pos == insertedBox.pos));
MyVector2 b1 = iterFreeBoxes->pos;
//MyVector2 b2 = MyVector2(iterFreeBoxes->pos.x + iterFreeBoxes->size.x,iterFreeBoxes->pos.y);
MyVector2 b3 = MyVector2(iterFreeBoxes->pos.x + iterFreeBoxes->size.x,iterFreeBoxes->pos.y + iterFreeBoxes->size.y);
//MyVector2 b4 = MyVector2(iterFreeBoxes->pos.x ,iterFreeBoxes->pos.y + iterFreeBoxes->size.y);
if ((a1.x >= b3.x) || (a1.y >= b3.y) ||
(a3.x <= b1.x) || (a3.y <= b1.y))
{
iterFreeBoxes++;
continue; // not intersecting
}
if ((a1.x > b1.x) /* && (a1.x < b3.x) */) // If there is a chance that line a1,a2 is in the shape b
{
freeBoxes.push_front(MyBox(
MyVector2(
iterFreeBoxes->pos.x,
iterFreeBoxes->pos.y),
MyVector2(
a1.x - b1.x,
iterFreeBoxes->size.y)
));
}
if ((a3.x < b3.x) /* && (a1.x < b3.x) */) // If there is a chance that line a1,a2 is in the shape b
{
freeBoxes.push_front(MyBox(
MyVector2(
a3.x,
iterFreeBoxes->pos.y),
MyVector2(
b3.x - a3.x,
iterFreeBoxes->size.y)
));
}
if ((a1.y > b1.y) /* && (a1.x < b3.x) */) // If there is a chance that line a1,a2 is in the shape b
{
freeBoxes.push_front(MyBox(
MyVector2(
iterFreeBoxes->pos.x,
iterFreeBoxes->pos.y),
MyVector2(
iterFreeBoxes->size.x,
a1.y - b1.y)
));
}
if ((a3.y < b3.y) /* && (a1.x < b3.x) */) // If there is a chance that line a1,a2 is in the shape b
{
freeBoxes.push_front(MyBox(
MyVector2(
iterFreeBoxes->pos.x,
a3.y),
MyVector2(
iterFreeBoxes->size.x,
b3.y - a3.y)
));
}
auto blah = iterFreeBoxes++;
freeBoxes.erase(blah);
}
for (auto iterFreeBoxes = freeBoxes.begin(); iterFreeBoxes != freeBoxes.end(); iterFreeBoxes++)
{
assert(iterFreeBoxes != freeBoxes.end());
auto iterFreeBoxes2 = iterFreeBoxes;
iterFreeBoxes2++;
while ( iterFreeBoxes2 != freeBoxes.end())
{
assert(iterFreeBoxes != freeBoxes.end());
assert(iterFreeBoxes2 != freeBoxes.end());
assert(iterFreeBoxes != iterFreeBoxes2);
//assert(!((*iterFreeBoxes).pos == (*iterFreeBoxes2).pos));
MyVector2 b1 = iterFreeBoxes->pos;
//MyVector2 b2 = MyVector2(iterFreeBoxes->pos.x + iterFreeBoxes->size.x,iterFreeBoxes->pos.y);
MyVector2 b3 = MyVector2(iterFreeBoxes->pos.x + iterFreeBoxes->size.x,iterFreeBoxes->pos.y + iterFreeBoxes->size.y);
//MyVector2 b4 = MyVector2(iterFreeBoxes->pos.x ,iterFreeBoxes->pos.y + iterFreeBoxes->size.y);
MyVector2 c1 = iterFreeBoxes2->pos;
//MyVector2 c2 = MyVector2(iterFreeBoxes2->pos.x + iterFreeBoxes2->size.x,iterFreeBoxes2->pos.y);
MyVector2 c3 = MyVector2(iterFreeBoxes2->pos.x + iterFreeBoxes2->size.x,iterFreeBoxes2->pos.y + iterFreeBoxes2->size.y);
//MyVector2 c4 = MyVector2(iterFreeBoxes2->pos.x ,iterFreeBoxes2->pos.y + iterFreeBoxes2->size.y);
if (c1.x >= b1.x && c1.y >= b1.y &&
c3.x <= b3.x && c3.y <= b3.y)
{
//std::cout<<"Erasing a box "<<iterFreeBoxes->pos<<", "<<iterFreeBoxes->size<<" and "<<iterFreeBoxes2->pos<<", "<<iterFreeBoxes2->size<<std::endl;
auto blah = iterFreeBoxes2++;
freeBoxes.erase(blah);
}
else
iterFreeBoxes2++;
}
}
/*
BOOSFOREACH(MyBox &lol, freeBoxes)
{
//std::cout<<"A free box with "<<lol.pos<<std::endl;
}
*/
rects.erase(minIterRects);
//std::cout<<"Finished with said loop"<<std::endl;
}
fine = 1;
return boxes;
}
int main(int argc, char *argv[])
{
std::string train_path;
std::string gt_path;
std::string output_file;
std::string output_patch_file;
int numbers = 0;
int start = 100;
int c;
std::vector<int> excludes(nexcludes);
excludes.assign(exclude_nums, exclude_nums + nexcludes);
while ((c = getopt(argc, argv, "i:g:n:s:e:o:p:h")) != -1) {
switch (c) {
case 'i':
train_path = optarg;
break;
case 'g':
gt_path = optarg;
break;
case 'n':
{
std::stringstream stream(optarg);
stream >> numbers;
}
break;
case 's':
{
std::stringstream stream(optarg);
stream >> start;
}
break;
case 'e':
excludes = spliti(std::string(optarg),',');
break;
case 'o':
output_file = optarg;
break;
case 'p':
output_patch_file = optarg;
break;
case 'h':
default:
std::cout << c << std::endl;
std::cerr << "Usage: extract_train_set OPTIONS" << std::endl
<< "\t -i <training directory>" << std::endl
<< "\t -g <gt box directory>" << std::endl
<< "\t -n <maximum id>" << std::endl
<< "\t -s <start id>" << std::endl
<< "\t -o <output path>" << std::endl
<< "\t -p <output patch file>" << std::endl
<< "\t -e <exclude list>" << std::endl;
return 1;
}
}
if (train_path == "" || gt_path == "") {
std::cerr << "Training path and gt path are mandatory" << std::endl;
return 1;
}
if (output_file == "") {
std::cerr << "output file is mandatory" << std::endl;
return 1;
}
srand(time(NULL));
std::ofstream ofs(output_file.c_str());
std::ofstream ofs_patch;
if (output_patch_file != "") {
ofs_patch.open(output_patch_file);
}
for (unsigned int i = start; i <= numbers; ++i) {
if (std::find(excludes.begin(), excludes.end(), i) != excludes.end()) continue;
std::cout << "Processing: " << i << std::endl;
std::string train_img;
std::string gt_box;
{
std::stringstream stream(train_path);
stream << train_path << "/" << i << ".jpg";
train_img = (stream.str());
}
{
std::stringstream stream(gt_path);
stream << gt_path << "/" << i << ".txt";
gt_box = (stream.str());
}
std::vector<cv::Rect> rects(read_boxes(gt_box));
cv::Mat img = cv::imread(train_img);
// first we extract the positive instances
for (unsigned int j = 0; j < rects.size(); ++j) {
extract_positive_samples(img, rects[j], ofs, ofs_patch);
}
std::cout << "Extracting random images" << std::endl;
// then we gonna extract negative samples
float size = img.rows;
cv::Mat scaledImage = img;
float scale = 1.0;
for (unsigned int j = 0; j < nscales; ++j) {
std::cout << "scale: " << size << std::endl;
if (scaledImage.rows > (int) size) {
float ratio = size / scaledImage.rows;
int h = (int) size;
int w = ratio * scaledImage.cols;
std::cout << w << " " << h << " " << ratio << std::endl;
cv::resize(img, scaledImage, cv::Size(w,h));
rects = scale_rects(rects, ratio);
scale = scale * ratio;
}
if (scaledImage.rows < window_height || scaledImage.cols < window_width) {
continue;
}
extract_negative_samples(scaledImage, rects, scale, ofs, ofs_patch);
size = size * scale_ratio;
}
}
return 0;
}
