コード例 #1
0
// runs the raytrace over all tests and saves the corresponding images
int main(int argc, char** argv) {
    
    // test that glfw and glew are linked properly
    uiloop();
    message("GLFW and GLEW seem to work\n\n");
    
    // test max_component function
    vec3f v(1,2,-3);
    float max_val = max_component(v);
    message("Result of max_component: %f\n", max_val);
    
    // test sum of three vectors
    vec3f va(1,0,0);
    vec3f vb(0,4,0);
    vec3f vc(0,0,2);
    vec3f vabc = sum_three(va, vb, vc);
    message("Result of sum_three: %s\n", tostring(vabc).c_str());
    
    // test sum of vectors
    vector<vec3f> vs = {
        {3.14,1.5,2.7},
        {2.71,8.2,8.2},
        {1.61,8.0,3.4},
        {1.41,4.2,1.4},
    };
    vec3f vsum = sum_many(vs);
    message("Result of sum_many: %s\n", tostring(vsum).c_str());

    message("\nThis message indicates a successful build!\n\n");

    return 0;
}
コード例 #2
0
ファイル: fscatter.c プロジェクト: irisvogon/fulldomain
EXPORT bool scatter_front(
	Front		*front)
{
	COMPONENT	max_comp;
	INTERFACE	*intfc = front->interf;
	RECT_GRID	*gr = front->rect_grid;
	bool		status;
	bool		sav_copy = copy_intfc_states();
	bool		sav_intrp = interpolate_intfc_states(intfc);
	int		i, dim = gr->dim;
	DEBUG_ENTER(scatter_front)
	
	max_comp = max_component(intfc);
	pp_global_imax(&max_comp,1L);

	add_time_start(3);

	if ((dim == 3) && debugging("consistency"))
	{
	    (void) printf("Check consistency of interface "
	                  "before scatter_front()\n");
	    if (!consistent_interface(intfc))
	    {
		screen("ERROR in scatter_front(),  input interface is "
		       "inconsistent\n");
		clean_up(ERROR);
	    }
	    (void) printf("Interface into scatter_front is consistent\n");
	}
	if (dim == 2)
	{
	    for (i = 0; i < dim; ++i)
		if ((gr->lbuf[i] > 0) || (gr->ubuf[i] > 0))
		     break;
	    if (i == dim)
	    {
		DEBUG_LEAVE(scatter_front)
		status = FUNCTION_SUCCEEDED; /* No subdomains to process */
		return pp_min_status(status);
	    }
	}

	set_copy_intfc_states(YES);
	interpolate_intfc_states(intfc) = NO;

	status = form_subintfc_via_communication(front);
	
	//if(dim == 3)
	//    delete_outside_surface(front->interf);
	
	max_comp = max_component(intfc);
	pp_global_imax(&max_comp,1L);
	max_component(intfc) = max_comp;

	interpolate_intfc_states(intfc) = sav_intrp;
	set_copy_intfc_states(sav_copy);

	if ((status) && (dim == 3) && debugging("consistency"))
	{
	    (void) printf("Check consistency of interface ");
	    (void) printf("after scatter_front()\n");
	    if (!consistent_interface(intfc))
	    {
		screen("ERROR in scatter_front(),  output interface is "
		       "inconsistent\n");
		clean_up(ERROR);
	    }
	}

	DEBUG_LEAVE(scatter_front)
	status = pp_min_status(status);
	
	add_time_end(3);

	return status;
}		/*end scatter_front*/
コード例 #3
0
Shape* read_ply(const string& filename, bool flipface, bool normalize, bool flipyz) {
    FILE* f = fopen(filename.c_str(), "rt");
    if(not f) ERROR("cannot open file %s", filename.c_str());
    
    char line[LINE_SIZE];
    
    // magic
    fgets(line, LINE_SIZE, f);
    if(not _startswith(line, "ply")) ERROR("unknown file format");
    
    // format
    fgets(line, LINE_SIZE, f);
    if(not _startswith(line, "format")) ERROR("unknown file format");
    
    // skip till vertex
    fgets(line, LINE_SIZE, f);
    while(not _startswith(line, "element vertex")) fgets(line, LINE_SIZE, f);
    
    // vertex
    int vertex_num = 0;
    sscanf(line, "element vertex %d", &vertex_num);
    
    // vertex props
    int vertex_pos = -1, vertex_norm = -1, vertex_uv = -1, vertex_col8 = -1, vertex_colf = -1;
    int vertex_vals = 0;
    fgets(line, LINE_SIZE, f);
    while(_startswith(line, "property")) {
        if(_startswith(line, "property float x") or _startswith(line, "property float32 x")) vertex_pos = vertex_vals;
        if(_startswith(line, "property float nx") or _startswith(line, "property float32 nx")) vertex_norm = vertex_vals;
        if(_startswith(line, "property uchar diffuse_red") or _startswith(line, "property uint8 diffuse_red")) vertex_col8 = vertex_vals;
        if(_startswith(line, "property uchar red") or _startswith(line, "property uint8 red")) vertex_col8 = vertex_vals;
        if(_startswith(line, "property float diffuse_red") or _startswith(line, "property float32 diffuse_red")) vertex_colf = vertex_vals;
        if(_startswith(line, "property float red") or _startswith(line, "property float32 red")) vertex_colf = vertex_vals;
        vertex_vals ++;
        fgets(line, LINE_SIZE, f);
    }
    
    // skip till faces
    while(not _startswith(line, "element face")) fgets(line, LINE_SIZE, f);
    
    // face
    int face_num = 0;
    sscanf(line, "element face %d", &face_num);
    
    // face props
    int face_start = -1;
    int face_vals = 0;
    fgets(line, LINE_SIZE, f);
    while(_startswith(line, "property")) {
        if(_startswith(line, "property list uchar int vertex_ind")) face_start = face_vals;
        if(_startswith(line, "property list uchar uint vertex_ind")) face_start = face_vals;
        if(_startswith(line, "property list uint8 int32 vertex_ind")) face_start = face_vals;
        if(_startswith(line, "property list char int vertex_ind")) face_start = face_vals;
        if(_startswith(line, "property list int8 int32 vertex_ind")) face_start = face_vals;
        face_vals ++;
        fgets(line, LINE_SIZE, f);
    }
    ERROR_IF_NOT(face_start>=0, "bad face start");
    
    // skip till end of header
    while(not _startswith(line, "end_header")) fgets(line, LINE_SIZE, f);
    
    // read vertex data
    vector<vec3f> pos; vector<vec3f> norm; vector<vec2f> uv;
    for(int i = 0; i < vertex_num; i ++) {
        vector<float> vdata;
        for(int j = 0; j < vertex_vals; j ++) {
            float v;
            fscanf(f, "%f", &v);
            vdata.push_back(v);
        }
        pos.push_back( vec3f(vdata[vertex_pos+0],vdata[vertex_pos+1],vdata[vertex_pos+2]) );
        if(vertex_norm >= 0) norm.push_back( vec3f(vdata[vertex_norm+0],vdata[vertex_norm+1],vdata[vertex_norm+2]) );
        if(vertex_uv >= 0) uv.push_back( vec2f(vdata[vertex_uv+0],vdata[vertex_uv+1] ));
    }
    
    if(normalize) {
        range3f bbox;
        for(auto v : pos) bbox = runion(bbox,v);
        vec3f c = center(bbox); float s = 1/max_component(size(bbox));
        for(vec3f& v : pos) v = (v-c)*s;
    }
    
    if(flipyz) {
        for(vec3f& v : pos) swap(v.y,v.z);
        for(vec3f& v : norm) swap(v.y,v.z);
    }
    
    // read vertex data
    vector<vec3i> triangles; vector<vec4i> quads;
    for(int i = 0; i < face_num; i ++) {
        int n = 0; fscanf(f, "%d", &n);
        if(n == 3) { vec3i face; for(int j=0;j<3;j++) fscanf(f, "%d", &(face[j])); triangles.push_back(face); }
        if(n == 4) { vec4i face; for(int j=0;j<4;j++) fscanf(f, "%d", &(face[j])); quads.push_back(face); }
        if(n != 3 and n != 4) ERROR("unsupported face type");
    }
    
    if(flipface) {
        for(vec3i& t : triangles) swap(t.y,t.z);
        for(vec4i& t : quads) swap(t.y,t.w);
    }
    
    fclose(f);
    
    if(triangles.size() == 0 and quads.size() > 0) {
        auto mesh = new Mesh();
        mesh->pos = pos;
        mesh->norm = norm;
        mesh->texcoord = uv;
        mesh->quad = quads;
        return mesh;
    } else if(triangles.size() > 0 and quads.size() == 0) {
        auto mesh = new TriangleMesh();
        mesh->pos = pos;
        mesh->norm = norm;
        mesh->texcoord = uv;
        mesh->triangle = triangles;
        return mesh;
    } else if(triangles.size() > 0 and quads.size() > 0) {
        auto mesh = new Mesh();
        mesh->pos = pos;
        mesh->norm = norm;
        mesh->texcoord = uv;
        mesh->triangle = triangles;
        mesh->quad = quads;
        return mesh;
    } else { WARNING("empty mesh"); return 0; }
}
コード例 #4
0
ファイル: comp.c プロジェクト: frontier-sunysb/FronTier
EXPORT COMPONENT new_component(
	COMPONENT	comp)
{
	COMPONENT  mincomp, maxcomp;
	HYPER_SURF **hs;
	INTERFACE    *intfc;
	struct Table *firstIT, *T;
	static COMPONENT last_reused_comp = NO_COMP;

	if (comp != NO_COMP)
	{
	    firstIT = interface_table_list();
	    switch (comp)
	    {
	    case UNUSED_COMP:
		maxcomp = INT_MIN;	mincomp = INT_MAX;
	        for (T = firstIT; T != NULL; T = T->next)
		{
		    intfc = T->interface;
		    maxcomp = max(maxcomp,max_component(intfc));
		    mincomp = min(mincomp,min_component(intfc));
		}
		++maxcomp;
		for (comp = mincomp; comp <= maxcomp; ++comp)
		{
		    if (comp == last_reused_comp)
		        continue;
		    for (T = firstIT; T != NULL; T = T->next)
		    {
		        intfc = T->interface;
		        if (is_exterior_comp(comp,intfc) ||
			    is_excluded_comp(comp,intfc))
			    break;
		        if (intfc->hss != NULL)
			{
		            for (hs = intfc->hss; *hs; ++hs)
		            {
		                if ((positive_component(*hs) == comp) ||
			            (negative_component(*hs) == comp))
			            break;
		            }
			    if (*hs)
			        break;
			}
		    }
		    if (T == NULL)
		        break;
		}
		last_reused_comp = comp;
		break;
	    case NEW_COMP:
		comp = INT_MIN;
	        for (T = firstIT; T != NULL; T = T->next)
		{
		    intfc = T->interface;
		    comp = max(comp,max_component(intfc));
		}
		++comp;
	        last_reused_comp = NO_COMP;
		break;
	    default:
	        last_reused_comp = NO_COMP;
		break;
	    }
	    for (T = firstIT; T != NULL; T = T->next)
	    {
		intfc = T->interface;
	        max_component(intfc) = max(comp,max_component(intfc));
	        min_component(intfc) = min(comp,min_component(intfc));
	    }
	}
	return comp;
}		/*end new_component*/