void ROI_Item::zero ()
{
Window::GrabContext context;
bind();
std::vector<GLubyte> data (info().dim(0)*info().dim(1));
for (int n = 0; n < info().dim(2); ++n)
upload_data ({ { 0, 0, n } }, { { info().dim(0), info().dim(1), 1 } }, reinterpret_cast<void*> (&data[0]));
}
void ROI_Item::zero ()
{
MRView::GrabContext context;
ASSERT_GL_MRVIEW_CONTEXT_IS_CURRENT;
bind();
vector<GLubyte> data (header().size(0)*header().size(1));
for (int n = 0; n < header().size(2); ++n)
upload_data ({ { 0, 0, n } }, { { header().size(0), header().size(1), 1 } }, reinterpret_cast<void*> (&data[0]));
ASSERT_GL_MRVIEW_CONTEXT_IS_CURRENT;
}
void Upload_Data(id_ip *data_server_list,int data_server_id, char *server_id_string)
{
char *data_server_ip;
data_server_ip = look_up_ip(data_server_list,data_server_id);
if(data_server_ip == NULL)
{
printf("\n ERROR : Cannot find ip of data server with ip:%d",data_server_id);
return;
}
if( upload_data(ST,data_server_ip,directory,server_id_string) == -1)
printf("Upload data error");
else
printf("\nData have been uploaded successfuly \n");
}
void ROI_Item::load (const MR::Image::Header& header) {
bind();
MR::Image::Buffer<bool> buffer (header);
auto vox = buffer.voxel();
std::vector<GLubyte> data (vox.dim(0)*vox.dim(1));
ProgressBar progress ("loading ROI image \"" + header.name() + "\"...");
for (auto outer = MR::Image::Loop(2,3) (vox); outer; ++outer) {
auto p = data.begin();
for (auto inner = MR::Image::Loop (0,2) (vox); inner; ++inner)
*(p++) = vox.value();
upload_data ({ { 0, 0, vox[2] } }, { { vox.dim(0), vox.dim(1), 1 } }, reinterpret_cast<void*> (&data[0]));
++progress;
}
filename = header.name();
}
void ROI_Item::load ()
{
ASSERT_GL_MRVIEW_CONTEXT_IS_CURRENT;
MRView::GrabContext context;
bind();
auto image = header().get_image<bool>();
vector<GLubyte> data (image.size(0)*image.size(1));
ProgressBar progress ("loading ROI image \"" + header().name() + "\"");
for (auto outer = MR::Loop(2) (image); outer; ++outer) {
auto p = data.begin();
for (auto inner = MR::Loop (0,2) (image); inner; ++inner)
*(p++) = image.value();
upload_data ({ { 0, 0, image.index(2) } }, { { image.size(0), image.size(1), 1 } }, reinterpret_cast<void*> (&data[0]));
++progress;
}
filename = header().name();
ASSERT_GL_MRVIEW_CONTEXT_IS_CURRENT;
}
int
main (int argc, char **argv)
{
GTimer *timer;
int frame_count;
GLuint handle;
GLenum err;
GTimer *frame_timer;
double direction = OPACITY_INCREMENT;
g_type_init();
grand = g_rand_new();
frame_timer = g_timer_new();
g_timer_start(frame_timer);
load_data();
canvas_pixbuf = gdk_pixbuf_new_from_file(CANVAS_FILENAME, NULL);
g_assert(canvas_pixbuf);
glutInit(&argc, argv);
glutCreateWindow("color-convert");
glutFullScreen();
err = glewInit();
g_assert(err == GLEW_OK);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, (float) WIDTH, (float) HEIGHT, 0.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDepthRange(0.0f, 1.0f);
glViewport(0, 0, WIDTH, HEIGHT);
glRasterPos2f(0.0f, 0.0f);
glEnable(GL_TEXTURE_2D);
handle = compile_program();
glUseProgram(handle);
setup_textures(handle);
frame_count = 1;
timer = g_timer_new();
while (TRUE) {
double elapsed;
GLint location;
opacity += direction;
if (opacity >= 1.0) {
direction = -OPACITY_INCREMENT;
} else if (opacity <= 0.0) {
direction = OPACITY_INCREMENT;
}
location = glGetUniformLocation(handle, "opacity");
glUniform1f(location, opacity);
upload_data();
draw_scene();
glutSwapBuffers();
frame_count ++;
elapsed = g_timer_elapsed(frame_timer, NULL) * 1000;
if (elapsed < FRAME_TIME_MS) {
g_usleep(1000 * (FRAME_TIME_MS - elapsed));
}
g_timer_start(frame_timer);
if (frame_count % 1000 == 0) {
double fps;
fps = 1000 / g_timer_elapsed(timer, NULL);
g_timer_start(timer);
g_print("Framerate: %gfps\n", fps);
}
}
}
Pointer<Scene> Loader3Ds::read(const char *path) {
Pointer<Scene> pScene;
char pathBuf[100];
strcpy(pathBuf,path);
char *const lastSlash = strrchr(pathBuf,'/');
const char* modPath = Core::Inst()->mResMan->modPath(path);
Lib3dsFile *const f3d = lib3ds_file_open(modPath);
if(!f3d)
return pScene;
int i;
LoaderTGA loadTGA;
pScene.alloc();
for(i=0; i<f3d->nmaterials; ++i) {
Pointer<Material> pMat = new Material();
pScene->mMaterials.insert(pMat);
const Lib3dsMaterial &m = *f3d->materials[i];
pMat->diffuse = glm::vec4( m.diffuse[0], m.diffuse[1], m.diffuse[2], 1.f );
pMat->specular = glm::vec4( m.specular[0],m.specular[1],m.specular[2],1.f );
pMat->glossiness = 100.f * m.shininess;
if( m.texture1_map.name[0] ) {
strcpy((lastSlash ? lastSlash+1 : pathBuf), m.texture1_map.name );
pMat->pTexture = loadTGA.read(pathBuf);
}
if(! pMat->pTexture )
pMat->pTexture = defColorTex;
}
for(i=0; i<f3d->nmeshes; ++i) {
Lib3dsMesh *const lm = f3d->meshes[i];
normalize(*lm);
qsort( lm->faces, lm->nfaces, sizeof(Lib3dsFace), Comparator::faces );
const Pointer< Array<VertexData> > pUnrolled = unroll_vertices(lm);
Pointer<Mesh> pMesh, pOrig = (doSquash ?
upload_data_squashed(*pUnrolled) : upload_data(*pUnrolled));
if(doTransform)
pOrig->pNode.alloc()->local = *reinterpret_cast<glm::mat4*>( lm->matrix );
//read face data
int j, prev = -1,start=0;
for(j=0; j<lm->nfaces; ++j) {
const int cur = lm->faces[j].material;
if(cur == prev) continue;
if( pMesh.get() )
pMesh->setup(GL_TRIANGLES,3*start,3*j);
List< Pointer<Material> > *pl = &pScene->mMaterials;
for(int counter=cur; pl && --counter>=0; pl=pl->next.get());
assert(pl);
pMesh = new Mesh(*pOrig);
pScene->mMeshes.insert(pMesh);
pMesh->pMaterial = pl->data;
start=j; prev=cur;
}
if(pMesh.get())
pMesh->setup(GL_TRIANGLES,3*start,3*j);
}
for(i=0; i<f3d->ncameras; ++i) {
Pointer<Camera> pCam = new Camera();
pScene->mCameras.insert(pCam);
const Lib3dsCamera &cam = *f3d->cameras[i];
pCam->near = cam.near_range;
if(pCam->near < 0.01f) {
//invalid near plane value!
pCam->near = 1.f;
}
pCam->far = cam.far_range;
pCam->fov = cam.fov;
const Pointer<Node> &pn = pCam->pNode = new Node();
pn->local = makeSpatial( cam.position, cam.target, cam.roll );
}
for(i=0; i<f3d->nlights; ++i) {
Pointer<Light> pLit = new Light();
pScene->mLights.insert(pLit);
const Lib3dsLight &lit = *f3d->lights[i];
pLit->near = lit.inner_range;
pLit->far = lit.outer_range;
pLit->fov = lit.falloff;
pLit->hotspot = lit.hotspot / lit.falloff;
pLit->attenuation = lit.attenuation;
pLit->color = lit.multiplier * glm::vec4( lit.color[0], lit.color[1], lit.color[2], 1.f );
const Pointer<Node> &pn = pLit->pNode = new Node();
pn->local = makeSpatial( lit.position, lit.target, lit.roll );
}
return pScene;
}
/* ================ client_thread_main() ================ */
void client_thread_main(zsock_t *pipe, void *user_data)
{
client_t *client = (client_t*)user_data;
int id = client->id;
UNUSED const char *file_data = client->file_data;
UNUSED uint32_t file_size = client->file_size;
trace_log("Client %d Ready.", id);
zsock_signal(pipe, 0);
char sz_id[16];
sprintf(sz_id, "%d", id);
message_send_status(pipe, MSG_STATUS_ACTOR_READY);
zsock_t *sock_client = zsock_new_req(client->endpoint);
if ( sock_client == NULL ){
error_log("Connect broker failed. Client %d", client->id);
return;
}
uint32_t file_count = 0;
while ( true ){
char key[NAME_MAX];
client_rebuild_data_key(client, file_count, key);
int retries = 0;
while ( retries++ < RETRIES ) {
int rc = 0;
if ( client->op_code == 1 ) {
rc = upload_data(sock_client, key, file_data, file_size);
} else if ( client->op_code == 2 ) {
rc = download_data(sock_client, key);
} else if ( client->op_code == 3 ) {
rc = delete_data(sock_client, key);
}
if ( rc == -2 ) break;
if ( rc == 0 ) break;
notice_log("Retry %d/%d...", retries, RETRIES);
zclock_sleep(1000);
}
/* ---------------- Check exit loop ---------------- */
file_count++;
if ( file_count % 100 == 1 || file_count + 5 >= client->total_files ){
info_log("Client %d Send message %d/%d", client->id, file_count, client->total_files);
}
if ( file_count >= client->total_files )
break;
}
message_send_status(pipe, MSG_STATUS_ACTOR_OVER);
zsock_destroy(&sock_client);
trace_log("Client %d Exit.", id);
}
int Video::upload_slice(
const string &srcPath,
const string &bucketName,
const string &dstPath,
const string &videoCover,
const string &bizAttr,
const string &title,
const string &desc,
const string &magicContext,
const int sliceSize,
const string &session) {
reset();
int ret = 0;
ret = access(srcPath.c_str(), F_OK | R_OK);
if (ret != 0) {
retCode = VIDEO_FILE_NOT_EXISTS;
retMsg = "file not exist or can not be read...";
return retCode;
}
string encodePath = videoUrlEncode(dstPath);
uint64_t expired = time(NULL) + EXPIRED_SECONDS;
string url = generateResUrl(bucketName, encodePath);
string sign =
Auth::appSign(
APPID, SECRET_ID, SECRET_KEY,
expired, bucketName);
vector<string> headers;
headers.push_back("Authorization: " + sign);
uint64_t fileSize = 0;
string sha1 = genFileSHA1AndLen(srcPath, &fileSize);
upload_prepare(fileSize, sha1, sign, url, videoCover, bizAttr, title, desc, magicContext, session, sliceSize);
dump_res();
if (retCode != 0) {
return retCode;
}
if (retJson["data"].isMember("url")) {
//秒传成功，直接返回了url
return retCode;
}
if (!retJson["data"].isMember("offset")
|| !retJson["data"].isMember("session")
|| !retJson["data"].isMember("slice_size")) {
return retCode;
}
upload_data(fileSize, sha1,
retJson["data"]["slice_size"].asUInt64(),
sign, url, srcPath,
retJson["data"]["offset"].asUInt64(),
retJson["data"]["session"].asString());
return retCode;
}
