bool VoxelTree::readFromSchematicFile(const char *fileName) {
_stopImport = false;
emit importProgress(0);
std::stringstream ss;
int err = retrieveData(std::string(fileName), ss);
if (err && ss.get() != TAG_Compound) {
qDebug("[ERROR] Invalid schematic file.\n");
return false;
}
ss.get();
TagCompound schematics(ss);
if (!schematics.getBlocksId() || !schematics.getBlocksData()) {
qDebug("[ERROR] Invalid schematic data.\n");
return false;
}
int max = (schematics.getWidth() > schematics.getLength()) ? schematics.getWidth() : schematics.getLength();
max = (max > schematics.getHeight()) ? max : schematics.getHeight();
int scale = 1;
while (max > scale) {scale *= 2;}
float size = 1.0f / scale;
emit importSize(size * schematics.getWidth(),
size * schematics.getHeight(),
size * schematics.getLength());
int create = 1;
int red = 128, green = 128, blue = 128;
int count = 0;
for (int y = 0; y < schematics.getHeight(); ++y) {
for (int z = 0; z < schematics.getLength(); ++z) {
emit importProgress((int) 100 * (y * schematics.getLength() + z) / (schematics.getHeight() * schematics.getLength()));
for (int x = 0; x < schematics.getWidth(); ++x) {
if (_stopImport) {
qDebug("[DEBUG] Canceled import at %d voxels.\n", count);
_stopImport = false;
return true;
}
int pos = ((y * schematics.getLength()) + z) * schematics.getWidth() + x;
int id = schematics.getBlocksId()[pos];
int data = schematics.getBlocksData()[pos];
create = 1;
computeBlockColor(id, data, red, green, blue, create);
switch (create) {
case 1:
createVoxel(size * x, size * y, size * z, size, red, green, blue, true);
++count;
break;
case 2:
switch (data) {
case 0:
createVoxel(size * x + size / 2, size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 1:
createVoxel(size * x , size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 2:
createVoxel(size * x , size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z + size / 2, size / 2, red, green, blue, true);
break;
case 3:
createVoxel(size * x , size * y + size / 2, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y + size / 2, size * z , size / 2, red, green, blue, true);
break;
}
count += 2;
// There's no break on purpose.
case 3:
createVoxel(size * x , size * y, size * z , size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y, size * z , size / 2, red, green, blue, true);
createVoxel(size * x , size * y, size * z + size / 2, size / 2, red, green, blue, true);
createVoxel(size * x + size / 2, size * y, size * z + size / 2, size / 2, red, green, blue, true);
count += 4;
break;
}
}
}
}
emit importProgress(100);
qDebug("Created %d voxels from minecraft import.\n", count);
return true;
}
void HtmlBookmarksImporter::processElement(const QWebElement &element)
{
QWebElement entryElement(element.findFirst(QLatin1String("dt, hr")));
while (!entryElement.isNull())
{
if (entryElement.tagName().toLower() == QLatin1String("hr"))
{
BookmarksManager::addBookmark(BookmarksModel::SeparatorBookmark, {}, getCurrentFolder());
++m_currentAmount;
emit importProgress(BookmarksImport, m_totalAmount, m_currentAmount);
}
else
{
BookmarksModel::BookmarkType type(BookmarksModel::UnknownBookmark);
QWebElement matchedElement(entryElement.findFirst(QLatin1String("dt > h3")));
if (matchedElement.isNull())
{
matchedElement = entryElement.findFirst(QLatin1String("dt > a"));
if (!matchedElement.isNull())
{
type = (matchedElement.hasAttribute(QLatin1String("FEEDURL")) ? BookmarksModel::FeedBookmark : BookmarksModel::UrlBookmark);
}
}
else
{
type = BookmarksModel::FolderBookmark;
}
if (type != BookmarksModel::UnknownBookmark && !matchedElement.isNull())
{
QMap<int, QVariant> metaData({{BookmarksModel::TitleRole, matchedElement.toPlainText()}});
const bool isUrlBookmark(type == BookmarksModel::UrlBookmark || BookmarksModel::FeedBookmark);
if (isUrlBookmark)
{
const QUrl url(matchedElement.attribute(QLatin1String("HREF")));
if (!areDuplicatesAllowed() && BookmarksManager::hasBookmark(url))
{
entryElement = entryElement.nextSibling();
continue;
}
metaData[BookmarksModel::UrlRole] = url;
}
if (matchedElement.hasAttribute(QLatin1String("SHORTCUTURL")))
{
const QString keyword(matchedElement.attribute(QLatin1String("SHORTCUTURL")));
if (!keyword.isEmpty() && !BookmarksManager::hasKeyword(keyword))
{
metaData[BookmarksModel::KeywordRole] = keyword;
}
}
if (matchedElement.hasAttribute(QLatin1String("ADD_DATE")))
{
const QDateTime dateTime(getDateTime(matchedElement, QLatin1String("ADD_DATE")));
if (dateTime.isValid())
{
metaData[BookmarksModel::TimeAddedRole] = dateTime;
metaData[BookmarksModel::TimeModifiedRole] = dateTime;
}
}
if (matchedElement.hasAttribute(QLatin1String("LAST_MODIFIED")))
{
const QDateTime dateTime(getDateTime(matchedElement, QLatin1String("LAST_MODIFIED")));
if (dateTime.isValid())
{
metaData[BookmarksModel::TimeModifiedRole] = dateTime;
}
}
if (isUrlBookmark && matchedElement.hasAttribute(QLatin1String("LAST_VISITED")))
{
const QDateTime dateTime(getDateTime(matchedElement, QLatin1String("LAST_VISITED")));
if (dateTime.isValid())
{
metaData[BookmarksModel::TimeVisitedRole] = dateTime;
}
}
BookmarksModel::Bookmark *bookmark(BookmarksManager::addBookmark(type, metaData, getCurrentFolder()));
++m_currentAmount;
emit importProgress(BookmarksImport, m_totalAmount, m_currentAmount);
if (type == BookmarksModel::FolderBookmark)
{
setCurrentFolder(bookmark);
processElement(entryElement);
}
if (entryElement.nextSibling().tagName().toLower() == QLatin1String("dd"))
{
bookmark->setItemData(entryElement.nextSibling().toPlainText(), BookmarksModel::DescriptionRole);
entryElement = entryElement.nextSibling();
}
}
}
entryElement = entryElement.nextSibling();
}
goToParent();
}
bool VoxelTree::readFromSquareARGB32Pixels(const char* filename) {
emit importProgress(0);
int minAlpha = INT_MAX;
QImage pngImage = QImage(filename);
for (int i = 0; i < pngImage.width(); ++i) {
for (int j = 0; j < pngImage.height(); ++j) {
minAlpha = std::min(qAlpha(pngImage.pixel(i, j)) , minAlpha);
}
}
int maxSize = std::max(pngImage.width(), pngImage.height());
int scale = 1;
while (maxSize > scale) {scale *= 2;}
float size = 1.0f / scale;
emit importSize(size * pngImage.width(), 1.0f, size * pngImage.height());
QRgb pixel;
int minNeighborhoodAlpha;
for (int i = 0; i < pngImage.width(); ++i) {
for (int j = 0; j < pngImage.height(); ++j) {
emit importProgress((100 * (i * pngImage.height() + j)) /
(pngImage.width() * pngImage.height()));
pixel = pngImage.pixel(i, j);
minNeighborhoodAlpha = qAlpha(pixel) - 1;
if (i != 0) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i - 1, j)));
}
if (j != 0) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i, j - 1)));
}
if (i < pngImage.width() - 1) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i + 1, j)));
}
if (j < pngImage.height() - 1) {
minNeighborhoodAlpha = std::min(minNeighborhoodAlpha, qAlpha(pngImage.pixel(i, j + 1)));
}
while (qAlpha(pixel) > minNeighborhoodAlpha) {
++minNeighborhoodAlpha;
createVoxel(i * size,
(minNeighborhoodAlpha - minAlpha) * size,
j * size,
size,
qRed(pixel),
qGreen(pixel),
qBlue(pixel),
true);
}
}
}
emit importProgress(100);
return true;
}
