void setFrameCount(size_t count)
{
m_frameCount = count;
if (count > 1) {
m_generator.clear();
m_generator = ImageFrameGenerator::create(fullSize(), m_data, true, true);
useMockImageDecoderFactory();
}
}
virtual void SetUp() override
{
ImageDecodingStore::instance()->setCacheLimitInBytes(1024 * 1024);
m_data = SharedBuffer::create();
m_generator = ImageFrameGenerator::create(fullSize(), m_data, false);
useMockImageDecoderFactory();
m_decodersDestroyed = 0;
m_frameBufferRequestCount = 0;
m_status = ImageFrame::FrameEmpty;
}
SparseMatrix::SparseMatrix(std::string env, std::string stif) {
// std::string filename("/home/popka/kursach/simple1_out_model/ENV.bin");
std::ifstream env_stream;
env_stream.open(env.c_str(), std::ios::binary);
if (env_stream.bad())
std::cout << "wrong file name " << env;
env_stream.seekg(0, std::ios_base::end);
const size_t count_of_elements(env_stream.tellg() / sizeof(int));
env_stream.seekg(0, std::ios_base::beg);
std::vector<size_t> sizes(count_of_elements);
int* buf(new int[count_of_elements]);
env_stream.read(static_cast<char*>(static_cast<void*>(buf)), count_of_elements * sizeof(int));
env_stream.close();
for (size_t i(0); i != sizes.size(); ++i) {
sizes[i] = buf[i];
}
delete[] buf;
table.resize(sizes.size());
size = sizes.size();
std::ifstream stif_stream;
stif_stream.open(stif.c_str(), std::ios::binary);
size_t fullSize(0);
stif_stream.seekg(0, std::ios_base::end);
fullSize = stif_stream.tellg();
stif_stream.seekg(0, std::ios_base::beg);
real* buf_m(new real[fullSize]);
stif_stream.read(static_cast<char*>(static_cast<void*>(buf_m)), fullSize);
stif_stream.close();
size_t sum(0);
for (size_t i=0 ;i<sizes.size(); ++i) {
std::vector<real> tmpl(sizes[i]);
for (size_t j=0; j<sizes[i]; ++j) {
tmpl[sizes[i]-j-1] = buf_m[sum+j];
if (abs(buf_m[sum+j]) >1e+40) std::cout << "BIG MATRIX ";
}
/* size_t k = i- (sizes[i] - 1);
std::cout << "\n sizes[i] = " << sizes[i] << " i=" << i <<" первый ненулевой" << k << std::endl;
std::cout << "\n SparseArray \n ============= \n ";
for (size_t m=0; m<tmpl.size(); m++) {
std::cout << tmpl[m] << " ";
}
std::cout << "\n Buf \n ============= \n ";
for (size_t m=0; m<tmpl.size(); m++) {
std::cout << buf_m[sum+m] << " ";
}
int as;
std::cin >> as;*/
table[i] = new SparseArray(tmpl, i - (sizes[i] - 1));
sum+=sizes[i];
}
delete[] buf_m;
}
TEST_F(ImageFrameGeneratorTest, frameHasAlpha)
{
setFrameStatus(ImageFrame::FramePartial);
char buffer[100 * 100 * 4];
m_generator->decodeAndScale(imageInfo(), 1, buffer, 100 * 4);
EXPECT_TRUE(m_generator->hasAlpha(1));
EXPECT_EQ(1, m_frameBufferRequestCount);
ImageDecoder* tempDecoder = 0;
EXPECT_TRUE(ImageDecodingStore::instance()->lockDecoder(m_generator.get(), fullSize(), &tempDecoder));
ASSERT_TRUE(tempDecoder);
static_cast<MockImageDecoder*>(tempDecoder)->setFrameHasAlpha(false);
ImageDecodingStore::instance()->unlockDecoder(m_generator.get(), tempDecoder);
setFrameStatus(ImageFrame::FrameComplete);
m_generator->decodeAndScale(imageInfo(), 1, buffer, 100 * 4);
EXPECT_EQ(2, m_frameBufferRequestCount);
EXPECT_FALSE(m_generator->hasAlpha(1));
}
TEST_F(ImageFrameGeneratorTest, frameHasAlpha)
{
setFrameStatus(ImageFrame::FramePartial);
char buffer[100 * 100 * 4];
m_generator->decodeAndScale(0, imageInfo(), buffer, 100 * 4);
EXPECT_TRUE(m_generator->hasAlpha(0));
EXPECT_EQ(1, m_decodeRequestCount);
ImageDecoder* tempDecoder = 0;
EXPECT_TRUE(ImageDecodingStore::instance().lockDecoder(m_generator.get(), fullSize(), &tempDecoder));
ASSERT_TRUE(tempDecoder);
tempDecoder->frameBufferAtIndex(0)->setHasAlpha(false);
ImageDecodingStore::instance().unlockDecoder(m_generator.get(), tempDecoder);
EXPECT_EQ(2, m_decodeRequestCount);
setFrameStatus(ImageFrame::FrameComplete);
m_generator->decodeAndScale(0, imageInfo(), buffer, 100 * 4);
EXPECT_EQ(3, m_decodeRequestCount);
EXPECT_FALSE(m_generator->hasAlpha(0));
}
void LOPuzzle::prepareForRenderIfNecessary()
{
if (puzzleObject!=0) return;
puzzleObject = new SunnyModelObj;
puzzleObject->loadFromSobjFile(getPath("Base/Objects/Puzzle","sh3do"));
puzzleObject->makeVBO(true, isVAOSupported, false);
for (short i = 1; i<=puzzleObject->objectsCount; i++)
{
//Part.001
char name[4];
name[0] = '0';
name[1] = '0' + i/10;
name[2] = '0' + i%10;
name[3] = '\0';
short num = puzzleObject->getObjectNumBySubName(name);
objectsNumbers[i-1] = num;
}
ObjectObj ** objects = puzzleObject->getObjects();
SunnyVector2D max(-99999,-99999),min(99999,99999);
for (short i = 0; i<puzzleObject->objectsCount; i++)
{
if (max.x<objects[i]->maxSize.x) max.x = objects[i]->maxSize.x;
if (max.y<objects[i]->maxSize.z) max.y = objects[i]->maxSize.z;
if (min.x>objects[i]->minSize.x) min.x = objects[i]->minSize.x;
if (min.y>objects[i]->minSize.z) min.y = objects[i]->minSize.z;
}
SunnyVector2D fullSize(max.x-min.x,max.y-min.y);
fullSize.x/=puzzleHorizontalSize;
fullSize.y/=puzzleVerticalSize;
for (short i = 0; i<puzzleObject->objectsCount; i++)
{
SunnyVector2D pos = SunnyVector2D(min.x + fullSize.x*(i%5 + 0.5), min.y + fullSize.y*(i/5 + 0.5));
partsTranslations[i] = SunnyVector3D(-pos.x,0,-pos.y);
}
}
void useMockImageDecoderFactory()
{
m_generator->setImageDecoderFactory(MockImageDecoderFactory::create(this, fullSize()));
}
void FastoHexEdit::paintEvent(QPaintEvent *event) {
if (mode_ == HEX_MODE) {
QPainter painter(viewport());
QSize areaSize = viewport()->size();
QSize widgetSize = fullSize();
const int charW = charWidth();
const int charH = charHeight();
int firstLineIdx = verticalScrollBar()->value();
int lastLineIdx = firstLineIdx + areaSize.height() / charH;
const QRect rect = stableRect(event->rect());
const int yPosStart = rect.top();
const int xPosStart = rect.left();
const int yPosEnd = rect.bottom();
const int xPosEnd = rect.right();
const int wid = xPosEnd - xPosStart;
const int height = yPosEnd - yPosStart;
const int widchars = wid - TextMarginXY * 2;
const int acharInLine = asciiCharInLine(widchars);
if (acharInLine <= 0) {
return;
}
const int xPosAscii = widchars/4 * 3; // line pos
const int xPosAsciiStart = xPosAscii + TextMarginXY;
int indexCount = data_.size() / acharInLine;
if (lastLineIdx > indexCount) {
lastLineIdx = indexCount;
if (data_.size() % acharInLine) {
lastLineIdx++;
}
}
verticalScrollBar()->setPageStep(areaSize.height() / charH);
verticalScrollBar()->setRange(0, (widgetSize.height() - areaSize.height()) / charH + 1);
painter.setPen(Qt::gray);
painter.drawLine(xPosAscii, yPosStart, xPosAscii, yPosEnd);
painter.setPen(Qt::black);
int size = data_.size();
for (int lineIdx = firstLineIdx, yPos = yPosStart;
lineIdx < lastLineIdx; lineIdx += 1, yPos += charH) {
QByteArray part = data_.begin() + (lineIdx * acharInLine);
int part_size = size / acharInLine ? acharInLine : size % acharInLine;
part.resize(part_size);
size -= part_size;
QByteArray hex = part.toHex();
painter.setBackgroundMode(Qt::OpaqueMode);
for (int xPos = xPosStart, i = 0; i < hex.size(); i++, xPos += 3 * charW) {
QString val = hex.mid(i * 2, 2);
QRect hexrect(xPos, yPos, 3 * charW, charH);
painter.drawText(hexrect, Qt::AlignLeft, val);
char ch = part[i];
if ((ch < 0x20) || (ch > 0x7e)) {
part[i] = '.';
}
}
painter.setBackgroundMode(Qt::TransparentMode);
QRect asciirect(xPosAsciiStart, yPos, acharInLine * charW, charH);
painter.drawText(asciirect, Qt::AlignLeft, part);
}
} else {
base_class::paintEvent(event);
}
}
float64 mtpFileLoader::currentProgress() const {
if (complete) return 1;
if (!fullSize()) return 0;
return float64(currentOffset()) / fullSize();
}
float64 FileLoader::currentProgress() const {
if (_complete) return 1.;
if (!fullSize()) return 0.;
return snap(float64(currentOffset()) / fullSize(), 0., 1.);
}
