LRESULT CMainDlg::OnDownload(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
WCHAR wcPath[MAX_PATH] = { 0 }, wcData[MAX_PATH] = { 0 };
int itype = lParam;
if (itype)
{
//下载文件
if (m_hDownload != NULL)
{
::PostMessage(m_hDownload, WM_DOWNLOAD, wParam, lParam);
}
}
else
{
std::string *precv = (std::string *)wParam;
std::string str;
int is = precv->find_last_of('/');
str.append(*precv, is + 1, precv->size());
c2w(wcData, MAX_PATH, str.c_str());
CFileDialog savedlg(FALSE, NULL, wcData, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, L"文件 (*.jpg; *.bmp; *.png)", m_hWnd);
if (IDOK == savedlg.DoModal(*this))
{
memset(wcData, 0, MAX_PATH);
c2w(wcData, MAX_PATH, precv->c_str());
wcscpy(wcPath, savedlg.m_szFileName);
URLDownloadToFile(0, wcData, wcPath, 0, NULL);
}
delete precv;
}
return 0;
}
bool readINI(char* option, char* key, int& value, char* path)
{
WCHAR wcOption[MAX_PATH] = { 0 }, wcKey[MAX_PATH] = { 0 }, wcPath[MAX_PATH] = { 0 };
c2w(wcOption, MAX_PATH, option);
c2w(wcKey, MAX_PATH, key);
c2w(wcPath, MAX_PATH, path);
value = GetPrivateProfileInt(wcOption, wcKey, 0, wcPath);
return true;
}
bool readINI(char* option, char* key, char* value, char* path)
{
WCHAR wcOption[MAX_PATH] = { 0 }, wcKey[MAX_PATH] = { 0 }, wcValue[MAX_PATH] = { 0 }, wcPath[MAX_PATH] = { 0 };
c2w(wcOption, MAX_PATH, option);
c2w(wcKey, MAX_PATH, key);
c2w(wcPath, MAX_PATH, path);
bool rs = GetPrivateProfileString(wcOption, wcKey, wcValue, wcValue, MAX_PATH, wcPath);
strcpy(value, w2c(wcValue));
return rs;
}
bool readINI(char* option, char* key, int& value)
{
WCHAR czPath[MAX_PATH];
GetCurrentDirectory(MAX_PATH, czPath);
wcscat(czPath, L"\\config.ini");
WCHAR wcOption[MAX_PATH] = { 0 }, wcKey[MAX_PATH] = { 0 };
c2w(wcOption, MAX_PATH, option);
c2w(wcKey, MAX_PATH, key);
value = GetPrivateProfileInt(wcOption, wcKey, 0, czPath);
return true;
}
bool writeINI(char* option, char* key, int value)
{
WCHAR czPath[MAX_PATH];
GetCurrentDirectory(MAX_PATH, czPath);
wcscat(czPath, L"\\config.ini");
WCHAR wcOption[MAX_PATH] = { 0 }, wcKey[MAX_PATH] = { 0 }, wcValue[MAX_PATH] = { 0 };
c2w(wcOption, MAX_PATH, option);
c2w(wcKey, MAX_PATH, key);
swprintf(wcValue, L"%d", value);
bool rs = ::WritePrivateProfileString(wcOption, wcKey, wcValue, czPath);
return rs;
}
bool readINI(char* option, char* key, char* value)
{
WCHAR czPath[MAX_PATH];
GetCurrentDirectory(MAX_PATH, czPath);
wcscat(czPath, L"\\config.ini");
WCHAR wcOption[MAX_PATH] = { 0 }, wcKey[MAX_PATH] = { 0 }, wcValue[MAX_PATH] = { 0 };
c2w(wcOption, MAX_PATH, option);
c2w(wcKey, MAX_PATH, key);
bool rs = GetPrivateProfileString(wcOption, wcKey, wcValue, wcValue, MAX_PATH, czPath);
strcpy(value, w2c(wcValue));
return rs;
}
void CMainDlg::ShowLog(std::string strUrl, int idty)
{
std::string str;
WCHAR wc[MAX_PATH], wlog[MAX_PATH];
if (strUrl.size() >= 100)
{
str.append(strUrl.c_str(), 100);
}
else
{
str = strUrl;
}
c2w(wc, MAX_PATH, str.c_str());
switch (idty)
{
case 1:
swprintf(wlog, L"正在连接网页:%s 中", wc);
break;
case 2:
swprintf(wlog, L"打开网页:%s 成功", wc);
break;
case 3:
swprintf(wlog, L"打开网页:%s 失败", wc);
break;
default:
break;
}
}
void PerspectiveCamera::Pdf_We(const Ray &ray, Float *pdfPos,
Float *pdfDir) const {
// Interpolate camera matrix and fail if $\w{}$ is not forward-facing
Transform c2w;
CameraToWorld.Interpolate(ray.time, &c2w);
Float cosTheta = Dot(ray.d, c2w(Vector3f(0, 0, 1)));
if (cosTheta <= 0) {
*pdfPos = *pdfDir = 0;
return;
}
// Map ray $(\p{}, \w{})$ onto the raster grid
Point3f pFocus = ray((lensRadius > 0 ? focalDistance : 1) / cosTheta);
Point3f pRaster = Inverse(RasterToCamera)(Inverse(c2w)(pFocus));
// Return zero probability for out of bounds points
Bounds2i sampleBounds = film->GetSampleBounds();
if (pRaster.x < sampleBounds.pMin.x || pRaster.x >= sampleBounds.pMax.x ||
pRaster.y < sampleBounds.pMin.y || pRaster.y >= sampleBounds.pMax.y) {
*pdfPos = *pdfDir = 0;
return;
}
// Compute lens area of perspective camera
Float lensArea = lensRadius != 0 ? (Pi * lensRadius * lensRadius) : 1;
*pdfPos = 1 / lensArea;
*pdfDir = 1 / (A * cosTheta * cosTheta * cosTheta);
}
void ON_wString::SetAt( int i, char c )
{
if ( i >= 0 && i < Header()->string_length ) {
CopyArray();
m_s[i] = c2w(c);
}
}
/**
* Get 64-bit file size and store it into given 64-bit integer.
*
* @param path file path
* @param pSize pointer to a 64-bit integer to store file size into
*/
void win32_set_filesize64(const char* path, uint64_t *pSize)
{
int try_no;
for(try_no = 0; try_no < 2; try_no++) {
HANDLE hFile;
DWORD fileSizeLow, fileSizeHigh;
wchar_t* wpath = c2w(path, try_no);
if(wpath == NULL) continue;
hFile = CreateFileW(wpath, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
free(wpath);
if(hFile == INVALID_HANDLE_VALUE) {
UINT error = GetLastError();
if(error != ERROR_FILE_NOT_FOUND && error != ERROR_PATH_NOT_FOUND) break;
} else {
fileSizeLow = GetFileSize(hFile, &fileSizeHigh);
/* it is strange but the correct method to check for error */
if(fileSizeLow == 0xffffffff && GetLastError() != 0) {
/* printf("error code = %u: %s\n", GetLastError(), filepath); */
} else {
*pSize = fileSizeLow + ( (uint64_t)fileSizeHigh << 32 );
}
CloseHandle(hFile);
break;
}
}
}
Spectrum PerspectiveCamera::We(const Interaction &p0, const Vector3f &w,
Point2f *pRasterPtr) const {
// Interpolate camera matrix and check if _w_ is forward-facing
Transform c2w;
CameraToWorld.Interpolate(p0.time, &c2w);
Float cosTheta = Dot(w, c2w(Vector3f(0, 0, 1)));
if (cosTheta <= 0) return 0;
// Map direction _w_ onto the raster grid
Point3f pFocus = p0.p + w / cosTheta * (lensRadius > 0 ? focalDistance : 1);
Point3f pRaster = Inverse(RasterToCamera)(Inverse(c2w)(pFocus));
// Return raster position if requested
if (pRasterPtr) *pRasterPtr = Point2f(pRaster.x, pRaster.y);
// Return zero importance for out of bounds points
Bounds2i sampleBounds = film->GetSampleBounds();
if (pRaster.x < sampleBounds.pMin.x || pRaster.x >= sampleBounds.pMax.x ||
pRaster.y < sampleBounds.pMin.y || pRaster.y >= sampleBounds.pMax.y)
return 0;
// Compute lens area of perspective camera
Float lensArea = lensRadius != 0 ? (Pi * lensRadius * lensRadius) : 1;
// Return importance for point on image plane
Float cos2Theta = cosTheta * cosTheta;
return Spectrum(1 / (A * lensArea * cos2Theta * cos2Theta));
}
void ON_wString::AppendToArray( int size, const char* s )
{
if ( size > 0 && s && s[0] ) {
ReserveArray(size + Header()->string_length );
Header()->string_length += c2w( size, s, Header()->string_capacity-Header()->string_length, &m_s[Header()->string_length] );
m_s[Header()->string_length] = 0;
}
}
/**
* Open directory iterator for reading the directory content.
*
* @param dir_path directory path
* @return pointer to directory stream. On error, NULL is returned,
* and errno is set appropriately.
*/
WIN_DIR* win_opendir(const char* dir_path)
{
WIN_DIR* d;
wchar_t* wpath;
/* append '\*' to the dir_path */
size_t len = strlen(dir_path);
char *path = (char*)malloc(len + 3);
if(!path) return NULL; /* failed, malloc also set errno = ENOMEM */
strcpy(path, dir_path);
strcpy(path + len, "\\*");
d = (WIN_DIR*)malloc(sizeof(WIN_DIR));
if(!d) {
free(path);
return NULL;
}
memset(d, 0, sizeof(WIN_DIR));
wpath = c2w(path, 0);
d->hFind = (wpath != NULL ?
FindFirstFileW(wpath, &d->findFileData) : INVALID_HANDLE_VALUE);
free(wpath);
if(d->hFind == INVALID_HANDLE_VALUE && GetLastError() != ERROR_ACCESS_DENIED) {
wpath = c2w(path, 1); /* try to use secondary codepage */
if(wpath) {
d->hFind = FindFirstFileW(wpath, &d->findFileData);
free(wpath);
}
}
free(path);
if(d->hFind == INVALID_HANDLE_VALUE && GetLastError() == ERROR_ACCESS_DENIED) {
free(d);
errno = EACCES;
return NULL;
}
set_errno_from_last_file_error();
d->state = (d->hFind == INVALID_HANDLE_VALUE ? -1 : 0);
d->dir.d_name = NULL;
return d;
}
/**
* Fill file information in the file_t structure.
*
* @param file the file information
* @param use_lstat nonzero if lstat() shall be used
* @return 0 on success, -1 on error
*/
int file_stat2(file_t* file, int use_lstat)
{
#ifdef _WIN32
int i;
(void)use_lstat; /* ignore on windows */
file->mtime = 0;
if (file->wpath) {
free(file->wpath);
file->wpath = NULL;
}
for (i = 0; i < 2; i++) {
file->wpath = c2w(file->path, i);
if (file->wpath == NULL) continue;
/* return on success */
if (file_statw(file) == 0) return 0;
free(file->wpath);
file->wpath = NULL;
}
/* NB: usually errno is set by the rsh_file_statw() call */
if (!errno) errno = EINVAL;
return -1;
#else
struct stat st;
int res = 0;
file->mode &= FILE_OPT_DONT_FREE_PATH;
do {
if (use_lstat) {
/* check for symlink */
if (lstat(file->path, &st) < 0) return -1;
if (!S_ISLNK(st.st_mode)) break;
/* it's a symlink */
file->mode |= FILE_IFLNK;
}
res = stat(file->path, &st);
} while (0);
file->size = st.st_size;
file->mtime = st.st_mtime;
if (S_ISDIR(st.st_mode)) {
file->mode |= FILE_IFDIR;
} else if (S_ISREG(st.st_mode)) {
/* it's a regular file or a symlink pointing to a regular file */
file->mode |= FILE_IFREG;
}
return res;
#endif /* _WIN32 */
}
/**
* stat() a file with encoding support.
*
* @param path the file path
* @param buffer pointer to the buffer to store file properties to
* @return 0 on success, -1 on error
*/
int win_stat(const char* path, struct rsh_stat_struct *buffer)
{
int i, res = -1;
for(i = 0; i < 2; i++) {
wchar_t* wpath = c2w(path, i);
if(wpath == NULL) continue;
res = clib_wstat(wpath, buffer);
free(wpath);
if(res == 0 || errno != ENOENT) break;
}
return res;
}
/**
* Convert given C-string from encoding specified by
* command line options to utf8.
*
* @param str the string to convert
* @return converted string on success, NULL on fail
*/
char* win_to_utf8(const char* str)
{
char* res;
wchar_t* buf;
assert((opt.flags & (OPT_UTF8 | OPT_OEM | OPT_ANSI)) != 0);
if(opt.flags & OPT_UTF8) return rsh_strdup(str);
if((buf = c2w(str, 0)) == NULL) return NULL;
res = wchar_to_cstr(buf, CP_UTF8, NULL);
free(buf);
return res;
}
//===============================================ShellExicute==========================================================//
bool shellExecute(const char * file, const char *params){
wchar_t * Wfile = c2w(file);
wchar_t * Wparams = c2w(params);
SHELLEXECUTEINFO ShellInfo;
memset(&ShellInfo, 0, sizeof(ShellInfo));
ShellInfo.cbSize = sizeof(ShellInfo);
ShellInfo.hwnd = NULL;
ShellInfo.lpVerb = NULL;
ShellInfo.lpFile = Wfile; // L"VisualSFM.exe" L前缀将常量char 转化成 wchar
ShellInfo.lpParameters = Wparams;
ShellInfo.nShow = SW_HIDE;
ShellInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
if( ShellExecuteEx(&ShellInfo)) {
WaitForSingleObject(ShellInfo.hProcess,INFINITE);
return true;
}
else{
return false;
}
}
/**
* Check if given file can be opened with exclusive write access.
*
* @param path path to the file
* @return 1 if file can be opened, 0 otherwise
*/
int can_open_exclusive(const char* path)
{
int i, res = 0;
for(i = 0; i < 2 && res == 0; i++) {
int fd;
wchar_t* wpath = c2w(path, i);
if(wpath == NULL) continue;
fd = _wsopen(wpath, _O_RDONLY | _O_BINARY, _SH_DENYWR, 0);
if(fd >= 0) {
res = 1;
_close(fd);
}
free(wpath);
}
return res;
}
void ON_wString::CopyToArray( int size, const char* s )
{
if ( size > 0 && s && s[0] ) {
ReserveArray(size);
Header()->string_length = c2w( size, s, Header()->string_capacity, m_s );
m_s[Header()->string_length] = 0;
}
else {
if ( Header()->ref_count > 1 )
Destroy();
else {
Header()->string_length = 0;
m_s[0] = 0;
}
}
}
int ON_wString::Find( const char* s ) const
{
int rc = -1;
if ( s && s[0] && !IsEmpty() ) {
const int s_count = (int)strlen(s); // the (int) is for 64 bit size_t conversion
wchar_t* w = (wchar_t*)onmalloc( (s_count+2)*sizeof(w[0]) );
c2w( s_count, s, s_count+1, w );
const wchar_t* p;
p = wcsstr( m_s, w );
if ( p )
{
rc = ((int)(p-m_s)); // the (int) cast is for 64 bit compilers
}
onfree( w );
}
return rc;
}
/**
* Open file path given in the current encoding, using desired shared access.
*
* @param path file path
* @param mode string specifying file opening mode
* @param exclusive non-zero to prohibit write access to the file
* @return file descriptor on success, NULL on error
*/
FILE* win_fopen_ex(const char* path, const char* mode, int exclusive)
{
FILE* fd = 0;
int i;
wchar_t* wmode = utf8_to_wchar(mode);
assert(wmode != NULL);
/* try two code pages */
for(i = 0; i < 2; i++) {
wchar_t* wpath = c2w(path, i);
if(wpath == NULL) continue;
fd = _wfsopen(wpath, wmode, (exclusive ? _SH_DENYWR : _SH_DENYNO));
free(wpath);
if(fd || errno != ENOENT) break;
}
free(wmode);
return fd;
}
bool TextureClass::Initialize(ID3D11Device* device, char* filename)
{
HRESULT result;
// Load the texture in.
WCHAR fn[200];
c2w(fn, 200, filename);
memcpy(m_textureFileName, filename, 200);
result = D3DX11CreateShaderResourceViewFromFile(device, fn, NULL, NULL, &m_texture, NULL);
if(FAILED(result))
{
return false;
}
return true;
}
Float PerspectiveCamera::Pdf_We(const Interaction &p0,
const Vector3f &w) const {
// Interpolate camera matrix and check if _w_ is forward-facing
Transform c2w;
CameraToWorld.Interpolate(p0.time, &c2w);
Float cosTheta = Dot(w, c2w(Vector3f(0, 0, 1)));
if (cosTheta <= 0) return 0;
// Map direction _w_ onto the raster grid
Point3f pFocus = p0.p + w / cosTheta * (lensRadius > 0 ? focalDistance : 1);
Point3f pRaster = Inverse(RasterToCamera)(Inverse(c2w)(pFocus));
// Return zero importance for out of bounds points
Bounds2i sampleBounds = film->GetSampleBounds();
if (pRaster.x < sampleBounds.pMin.x || pRaster.x >= sampleBounds.pMax.x ||
pRaster.y < sampleBounds.pMin.y || pRaster.y >= sampleBounds.pMax.y)
return 0;
return 1 / (A * cosTheta * cosTheta * cosTheta);
}
/**
* Fill file information in the file_t structure.
*
* @param file the file information
* @param use_lstat nonzero if lstat() shall be used
* @return 0 on success, -1 on error
*/
int rsh_file_stat2(file_t* file, int use_lstat)
{
struct rsh_stat_struct st;
int res = -1;
#ifdef _WIN32
int i;
(void)use_lstat; /* ignore on windows */
if(file->wpath) {
free(file->wpath);
file->wpath = NULL;
}
for(i = 0; i < 2; i++) {
wchar_t* wpath = c2w(file->path, i);
if(wpath == NULL) continue;
res = clib_wstat(wpath, &st);
if(res == 0 || errno != ENOENT) {
file->wpath = wpath;
file->size = st.st_size;
/* set correct filesize for large files under win32 */
win32_set_filesize64(file->path, &file->size);
break;
}
free(wpath);
}
#else
res = (use_lstat ? lstat(file->path, &st) :
rsh_stat(file->path, &st));
file->size = st.st_size;
#endif /* _WIN32 */
file->mtime = st.st_mtime;
return res;
}
int ON_wString::ReverseFind( char c ) const
{
wchar_t w = c2w(c);
return ReverseFind( w );
}
int ON_wString::ReverseFind( unsigned char c ) const
{
wchar_t w = c2w((char)c);
return ReverseFind( w );
}
K py(K f, K x, K lib)
{
int argc; char **argv;
char *error, *p, *buf;
void *h;
K r;
#ifdef PY3K
char *oldloc;
#endif
h = dlopen((const char *)kG(lib), RTLD_NOW|RTLD_GLOBAL);
if (!h)
R krr(dlerror());
dlerror(); /* Clear any existing error */
Py_Main = dlsym(h, "Py_Main");
P((error = dlerror()),krr(error));
P(xt, krr("argv type"));
I m = 0; /* buf length */
DO(xn,
K y;
P((y = kK(x)[i])->t!=KC, krr("arg type"));
m += y->n+1);
argc = xn+1;
argv = malloc(sizeof(char*) * argc);
P(!argv, krr("memory"));
buf = malloc(m);
P(!buf,(free(argv),krr("memory")));
argv[0] = f->s;
p = buf;
DO(xn,
K y = kK(x)[i];
argv[i+1] = memcpy(p, kG(y), y->n);
p += y->n; *p++ = '\0');
#ifdef PY3K
dlerror(); /* Clear any existing error */
#if PY3K < 35
c2w = dlsym(h, "_Py_char2wchar");
#else
c2w = dlsym(h, "Py_DecodeLocale");
#endif
P((error = dlerror()),krr(error));
dlerror(); /* Clear any existing error */
#if PY3K < 34
PyMem_Free = dlsym(h, "PyMem_Free");
#else
PyMem_Free = dlsym(h, "PyMem_RawFree");
#endif
P((error = dlerror()),krr(error));
wchar_t **wargv = malloc(sizeof(wchar_t*)*(argc+1));
wchar_t **wargv_copy = malloc(sizeof(wchar_t*)*(argc+1));
oldloc = strdup(setlocale(LC_ALL, NULL));
setlocale(LC_ALL, "");
DO(argc,P(!(wargv[i]=c2w(argv[i],NULL)),krr("decode")));
memcpy(wargv_copy, wargv, sizeof(wchar_t*)*argc);
setlocale(LC_ALL, oldloc);
free(oldloc);
wargv[argc] = wargv_copy[argc] = NULL;
r = ki(Py_Main(argc, wargv));
DO(argc,PyMem_Free(wargv_copy[i]));
free(wargv_copy);
free(wargv);
#else
r = ki(Py_Main(argc, argv));
#endif
dlclose(h);
free(argv);
free(buf);
R r;
}
