Example #1
0
void test(const char* proc_name,const TDrawMandelbrotProc fproc){
    const long max_iter=1000;
    TViewRect rect;
    rect.x0=-0.5;
    rect.y0=0;
    rect.r=2;

    TPixels32 dstPic;
    dstPic.resizeFast(640,480);

    std::cout<<proc_name<<": ";
    fproc(dstPic.getRef(),rect,max_iter);
    std::cout<<" ok"<<std::endl;

    { //save pic
        std::string dstFileName(proc_name);
        dstFileName+=".bmp";
#if defined(__APPLE__) && defined(__MACH__)
        TFileOutputStream bmpOutStream("/Users/hss/Desktop/GraphicDemo/ColorToGray/"+dstFileName);
#else
        TFileOutputStream bmpOutStream(dstFileName.c_str());
#endif
        TBmpFile::save(dstPic.getRef(),&bmpOutStream);//保存结果图片
    }
}
void KisAslLayerStyleSerializerTest::testReadMultipleStyles()
{
    KisPSDLayerStyleSP style(new KisPSDLayerStyle());

    QVector<KisPSDLayerStyleSP> styles;

    {
        KisAslLayerStyleSerializer s;

        QString srcFileName(TestUtil::fetchDataFileLazy("asl/multiple_styles.asl"));
        QFile aslFile(srcFileName);
        aslFile.open(QIODevice::ReadOnly);
        s.readFromDevice(&aslFile);

        styles = s.styles();
    }


    {
        KisAslLayerStyleSerializer s;

        QString dstFileName("multiple_styles_out.asl");
        QFile aslFile(dstFileName);
        aslFile.open(QIODevice::WriteOnly);

        s.setStyles(styles);
        s.saveToDevice(&aslFile);
    }

    {
        KisAslLayerStyleSerializer s;

        QString srcFileName("multiple_styles_out.asl");
        QFile aslFile(srcFileName);
        aslFile.open(QIODevice::ReadOnly);
        s.readFromDevice(&aslFile);

        styles = s.styles();

        dbgKrita << ppVar(styles.size());
    }
}
Example #3
0
void test(const char* proc_name,const TDrawMandelbrotProc fproc){
    const long max_iter=1000;
    TViewRect rect;
    rect.x0=-0.5;
    rect.y0=0;
    rect.r=2;
    rect.seta=0;

    TPixels32 dstPic;
    dstPic.resizeFast(640,480);

    std::cout<<proc_name<<": ";
    fproc(dstPic.getRef(),rect,max_iter);
    std::cout<<" ok"<<std::endl;

    { //save pic
        std::string dstFileName(proc_name);
        dstFileName+=".bmp";
        TFileOutputStream bmpOutStream(dstFileName.c_str());
        TBmpFile::save(dstPic.getRef(),&bmpOutStream);//保存结果图片
    }
}
mxAPPLICATION_ENTRY_POINT

int mxAppMain()
{
	SetupBaseUtil	setupBase;
	//FileLogUtil		fileLog;
	SetupCoreUtil	setupCore;


	const String	srcFileName(
		"D:/dev/_assets/_diplomarbeit/iryoku-head/Head.sdkmesh"
		//"D:/research/_current/iryoku-separable-sss-f61b44c/Demo/Media/Head.sdkmesh"
		//"D:/dev/_assets/Head.sdkmesh"
		);


	FileReader	srcFile( srcFileName );
	CHK_VRET_X_IF_NOT( srcFile.IsOpen(), -1 );


	StaticTriangleMeshData	staticMeshData;

	{
		SDKMesh		sdkMesh;
		if( FAILED(sdkMesh.Create(mxTO_UNICODE( srcFileName ))) ) {
			return -1;
		}

		const SDKMESH_HEADER& header = *sdkMesh.GetHeader();
		(void)header;

		const UINT numMeshes = sdkMesh.GetNumMeshes();
		Assert(numMeshes == 1);
		const UINT iFirstMesh = 0;

		const UINT numSubsets = sdkMesh.GetNumSubsets( iFirstMesh );
		Assert( numSubsets == 1 );
		const UINT iFirstSubset = 0;

		const SDKMESH_SUBSET* pSubset = sdkMesh.GetSubset( iFirstMesh, iFirstSubset );
		const UINT numVertices = pSubset->VertexCount;
		const UINT numIndices = pSubset->IndexCount;

		const UINT numVBs = sdkMesh.GetNumVBs();
		Assert( numVBs == 1 );

		const UINT numIBs = sdkMesh.GetNumIBs();
		Assert( numIBs == 1 );

		const SDKMeshVertex* srcVertices = (const SDKMeshVertex*) sdkMesh.GetRawVerticesAt(0);

		const SDKMESH_INDEX_TYPE indexType = sdkMesh.GetIndexType( iFirstMesh );
		Assert( indexType == SDKMESH_INDEX_TYPE::IT_16BIT );

		const UINT16* srcIndices = (const UINT16*) sdkMesh.GetRawIndicesAt(0);

		{
			TList< Vec3D > &	positions	= staticMeshData.positions;
			TList< Vec2D > &	texCoords	= staticMeshData.texCoords;
			TList< Vec3D > &	normals		= staticMeshData.normals;
			//TList< Vec3D > &	binormals	= staticMeshData.binormals;
			TList< Vec3D > &	tangents	= staticMeshData.tangents;

			positions.SetNum( numVertices );
			texCoords.SetNum( numVertices );
			normals.SetNum( numVertices );
			tangents.SetNum( numVertices );

			staticMeshData.localBounds.Clear();

			for( UINT iVertex = 0; iVertex < numVertices; iVertex++ )
			{
				const SDKMeshVertex & srcVertex = srcVertices[ iVertex ];

				Assert( srcVertex.normal.IsNormalized() );
				Assert( srcVertex.tangent.IsNormalized() );

				positions[ iVertex ] = srcVertex.position;
				texCoords[ iVertex ] = srcVertex.texCoord;
				normals[ iVertex ] = srcVertex.normal;
				tangents[ iVertex ] = srcVertex.tangent;

				staticMeshData.localBounds.AddPoint( srcVertex.position );
			}

			staticMeshData.indices.AddBytes( srcIndices, numIndices * sizeof srcIndices[0] );
			staticMeshData.indexStride = sizeof srcIndices[0];

			MeshPart & firstBatch = staticMeshData.batches.Add();
			{
				firstBatch.baseVertex = pSubset->VertexStart;
				firstBatch.startIndex = pSubset->IndexStart;
				firstBatch.indexCount = pSubset->IndexCount;
				firstBatch.vertexCount = pSubset->VertexCount;
			}
		}
	}



	const String	dstPathName(
		//"D:/dev/_assets"
		"R:/"
		);

	String	dstFileName(
		"iryoku-Head"
		);
	//srcFileName.ExtractFileBase( dstFileName );
	dstFileName += ".static_mesh";


	FileWriter	dstFile( dstPathName + dstFileName );
	CHK_VRET_X_IF_NOT( dstFile.IsOpen(), -1 );

	ArchivePODWriter	archive( dstFile );

	staticMeshData.Serialize( archive );

	return 0;
}
Example #5
0
void ArticleWriter::CompleteFileParts()
{
	debug("Completing file parts");
	debug("ArticleFilename: %s", m_fileInfo->GetFilename());

	bool directWrite = (g_Options->GetDirectWrite() || m_fileInfo->GetForceDirectWrite()) && m_fileInfo->GetOutputInitialized();

	BString<1024> nzbName;
	BString<1024> nzbDestDir;
	BString<1024> filename;

	{
		GuardedDownloadQueue guard = DownloadQueue::Guard();
		nzbName = m_fileInfo->GetNzbInfo()->GetName();
		nzbDestDir = m_fileInfo->GetNzbInfo()->GetDestDir();
		filename = m_fileInfo->GetFilename();
	}

	BString<1024> infoFilename("%s%c%s", *nzbName, PATH_SEPARATOR, *filename);

	bool cached = m_fileInfo->GetCachedArticles() > 0;

	if (g_Options->GetRawArticle())
	{
		detail("Moving articles for %s", *infoFilename);
	}
	else if (directWrite && cached)
	{
		detail("Writing articles for %s", *infoFilename);
	}
	else if (directWrite)
	{
		detail("Checking articles for %s", *infoFilename);
	}
	else
	{
		detail("Joining articles for %s", *infoFilename);
	}

	// Ensure the DstDir is created
	CString errmsg;
	if (!FileSystem::ForceDirectories(nzbDestDir, errmsg))
	{
		m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
			"Could not create directory %s: %s", *nzbDestDir, *errmsg);
		return;
	}

	CString ofn;
	if (m_fileInfo->GetForceDirectWrite())
	{
		ofn.Format("%s%c%s", *nzbDestDir, PATH_SEPARATOR, *filename);
	}
	else
	{
		ofn = FileSystem::MakeUniqueFilename(nzbDestDir, *filename);
	}

	DiskFile outfile;
	BString<1024> tmpdestfile("%s.tmp", *ofn);

	if (!g_Options->GetRawArticle() && !directWrite)
	{
		FileSystem::DeleteFile(tmpdestfile);
		if (!outfile.Open(tmpdestfile, DiskFile::omWrite))
		{
			m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
				"Could not create file %s: %s", *tmpdestfile, *FileSystem::GetLastErrorMessage());
			return;
		}
	}
	else if (directWrite && cached)
	{
		if (!outfile.Open(m_outputFilename, DiskFile::omReadWrite))
		{
			m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
				"Could not open file %s: %s", *m_outputFilename, *FileSystem::GetLastErrorMessage());
			return;
		}
		tmpdestfile = *m_outputFilename;
	}
	else if (g_Options->GetRawArticle())
	{
		FileSystem::DeleteFile(tmpdestfile);
		if (!FileSystem::CreateDirectory(ofn))
		{
			m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
				"Could not create directory %s: %s", *ofn, *FileSystem::GetLastErrorMessage());
			return;
		}
	}

	if (outfile.Active())
	{
		SetWriteBuffer(outfile, 0);
	}

	uint32 crc = 0;

	{
		std::unique_ptr<ArticleCache::FlushGuard> flushGuard;
		if (cached)
		{
			flushGuard = std::make_unique<ArticleCache::FlushGuard>(g_ArticleCache->GuardFlush());
		}

		CharBuffer buffer;
		bool firstArticle = true;

		if (!g_Options->GetRawArticle() && !directWrite)
		{
			buffer.Reserve(1024 * 64);
		}

		for (ArticleInfo* pa : m_fileInfo->GetArticles())
		{
			if (pa->GetStatus() != ArticleInfo::aiFinished)
			{
				continue;
			}

			if (!g_Options->GetRawArticle() && !directWrite && pa->GetSegmentOffset() > -1 &&
				pa->GetSegmentOffset() > outfile.Position() && outfile.Position() > -1)
			{
				memset(buffer, 0, buffer.Size());
				if (!g_Options->GetSkipWrite())
				{
					while (pa->GetSegmentOffset() > outfile.Position() && outfile.Position() > -1 &&
						outfile.Write(buffer, std::min((int)(pa->GetSegmentOffset() - outfile.Position()), buffer.Size())));
				}
			}

			if (pa->GetSegmentContent())
			{
				if (!g_Options->GetSkipWrite())
				{
					outfile.Seek(pa->GetSegmentOffset());
					outfile.Write(pa->GetSegmentContent(), pa->GetSegmentSize());
				}
				pa->DiscardSegment();
			}
			else if (!g_Options->GetRawArticle() && !directWrite && !g_Options->GetSkipWrite())
			{
				DiskFile infile;
				if (pa->GetResultFilename() && infile.Open(pa->GetResultFilename(), DiskFile::omRead))
				{
					int cnt = buffer.Size();
					while (cnt == buffer.Size())
					{
						cnt = (int)infile.Read(buffer, buffer.Size());
						outfile.Write(buffer, cnt);
					}
					infile.Close();
				}
				else
				{
					m_fileInfo->SetFailedArticles(m_fileInfo->GetFailedArticles() + 1);
					m_fileInfo->SetSuccessArticles(m_fileInfo->GetSuccessArticles() - 1);
					m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
						"Could not find file %s for %s [%i/%i]",
						pa->GetResultFilename(), *infoFilename, pa->GetPartNumber(),
						(int)m_fileInfo->GetArticles()->size());
				}
			}
			else if (g_Options->GetRawArticle())
			{
				BString<1024> dstFileName("%s%c%03i", *ofn, PATH_SEPARATOR, pa->GetPartNumber());
				if (!FileSystem::MoveFile(pa->GetResultFilename(), dstFileName))
				{
					m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
						"Could not move file %s to %s: %s", pa->GetResultFilename(),
						*dstFileName, *FileSystem::GetLastErrorMessage());
				}
			}

			if (m_format == Decoder::efYenc)
			{
				crc = firstArticle ? pa->GetCrc() : Crc32::Combine(crc, pa->GetCrc(), pa->GetSegmentSize());
				firstArticle = false;
			}
		}

		buffer.Clear();
	}

	if (outfile.Active())
	{
		outfile.Close();
		if (!directWrite && !FileSystem::MoveFile(tmpdestfile, ofn))
		{
			m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
				"Could not move file %s to %s: %s", *tmpdestfile, *ofn,
				*FileSystem::GetLastErrorMessage());
		}
	}

	if (directWrite)
	{
		if (!FileSystem::SameFilename(m_outputFilename, ofn) &&
			!FileSystem::MoveFile(m_outputFilename, ofn))
		{
			m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
				"Could not move file %s to %s: %s", *m_outputFilename, *ofn,
				*FileSystem::GetLastErrorMessage());
		}

		// if destination directory was changed delete the old directory (if empty)
		int len = strlen(nzbDestDir);
		if (!(!strncmp(nzbDestDir, m_outputFilename, len) &&
			(m_outputFilename[len] == PATH_SEPARATOR || m_outputFilename[len] == ALT_PATH_SEPARATOR)))
		{
			debug("Checking old dir for: %s", *m_outputFilename);
			BString<1024> oldDestDir;
			oldDestDir.Set(m_outputFilename, (int)(FileSystem::BaseFileName(m_outputFilename) - m_outputFilename));
			if (FileSystem::DirEmpty(oldDestDir))
			{
				debug("Deleting old dir: %s", *oldDestDir);
				FileSystem::RemoveDirectory(oldDestDir);
			}
		}
	}

	if (!directWrite)
	{
		for (ArticleInfo* pa : m_fileInfo->GetArticles())
		{
			if (pa->GetResultFilename())
			{
				FileSystem::DeleteFile(pa->GetResultFilename());
			}
		}
	}

	if (m_fileInfo->GetTotalArticles() == m_fileInfo->GetSuccessArticles())
	{
		m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkInfo, "Successfully downloaded %s", *infoFilename);
	}
	else if (m_fileInfo->GetMissedArticles() + m_fileInfo->GetFailedArticles() > 0)
	{
		m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkWarning,
			"%i of %i article downloads failed for \"%s\"",
			m_fileInfo->GetMissedArticles() + m_fileInfo->GetFailedArticles(),
			m_fileInfo->GetTotalArticles(), *infoFilename);
	}
	else
	{
		m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkInfo, "Partially downloaded %s", *infoFilename);
	}

	{
		GuardedDownloadQueue guard = DownloadQueue::Guard();

		m_fileInfo->SetCrc(crc);
		m_fileInfo->SetOutputFilename(ofn);

		if (strcmp(m_fileInfo->GetFilename(), filename))
		{
			// file was renamed during completion, need to move the file
			ofn = FileSystem::MakeUniqueFilename(nzbDestDir, m_fileInfo->GetFilename());
			if (!FileSystem::MoveFile(m_fileInfo->GetOutputFilename(), ofn))
			{
				m_fileInfo->GetNzbInfo()->PrintMessage(Message::mkError,
					"Could not rename file %s to %s: %s", m_fileInfo->GetOutputFilename(),
					*ofn, *FileSystem::GetLastErrorMessage());
			}
			m_fileInfo->SetOutputFilename(ofn);
		}

		if (strcmp(m_fileInfo->GetNzbInfo()->GetDestDir(), nzbDestDir))
		{
			// destination directory was changed during completion, need to move the file
			MoveCompletedFiles(m_fileInfo->GetNzbInfo(), nzbDestDir);
		}
	}
}