/*****************************************************************************
 * Render: displays previously rendered output
 *****************************************************************************
 * This function send the currently rendered image to adjust modified image,
 * waits until it is displayed and switch the two rendering buffers, preparing
 * next frame.
 *****************************************************************************/
static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
{
    picture_t *p_outpic;
    filter_sys_t *p_sys = p_filter->p_sys;

    vlc_mutex_lock( &p_sys->lock );
    int i_simthres = p_sys->i_simthres;
    int i_satthres = p_sys->i_satthres;
    int i_color = p_sys->i_color;
    vlc_mutex_unlock( &p_sys->lock );

    if( !p_pic ) return NULL;

    p_outpic = filter_NewPicture( p_filter );
    if( !p_outpic )
    {
        picture_Release( p_pic );
        return NULL;
    }

    /* Copy the Y plane */
    plane_CopyPixels( &p_outpic->p[Y_PLANE], &p_pic->p[Y_PLANE] );

    /*
     * Do the U and V planes
     */
    int refu, refv, reflength;
    GetReference( &refu, &refv, &reflength, i_color );

    for( int y = 0; y < p_pic->p[U_PLANE].i_visible_lines; y++ )
    {
        uint8_t *p_src_u = &p_pic->p[U_PLANE].p_pixels[y * p_pic->p[U_PLANE].i_pitch];
        uint8_t *p_src_v = &p_pic->p[V_PLANE].p_pixels[y * p_pic->p[V_PLANE].i_pitch];
        uint8_t *p_dst_u = &p_outpic->p[U_PLANE].p_pixels[y * p_outpic->p[U_PLANE].i_pitch];
        uint8_t *p_dst_v = &p_outpic->p[V_PLANE].p_pixels[y * p_outpic->p[V_PLANE].i_pitch];

        for( int x = 0; x < p_pic->p[U_PLANE].i_visible_pitch; x++ )
        {
            if( IsSimilar( *p_src_u - 0x80, *p_src_v - 0x80,
                           refu, refv, reflength,
                           i_satthres, i_simthres ) )

            {
                *p_dst_u++ = *p_src_u;
                *p_dst_v++ = *p_src_v;
            }
            else
            {
                *p_dst_u++ = 0x80;
                *p_dst_v++ = 0x80;
            }
            p_src_u++;
            p_src_v++;
        }
    }

    return CopyInfoAndRelease( p_outpic, p_pic );
}
void Comparer::Compare(Tree *tree1, Tree *tree2)
{
	std::multiset<Node *, NCompare> SNodes1, SNodes2;
	std::multiset<Node *, NCompare>::iterator SNIter1, SNIter2;
	std::vector<Node *> child;
	element e1, e2;
	bool delpair=false;
	std::pair<std::multiset<Node *, NCompare>::iterator, std::multiset<Node *, NCompare>::iterator> p;
	SortTree(tree1->getTRoot(), SNodes1);
	SortTree(tree2->getTRoot(), SNodes2);
	SNodes1.erase(tree1->getTRoot());
	SNodes2.erase(tree2->getTRoot());
	for (SNIter1 = SNodes1.begin(); SNIter1 != SNodes1.end(); SNIter1++)
	{

		p = SNodes2.equal_range(*SNIter1);

		//for (SNIter2 = SNodes2.begin(); SNIter2 != SNodes2.end(); SNIter2++)		
		for (SNIter2 = p.first; SNIter2 != p.second; SNIter2++)
		{
			
			if (IsSimilar(*SNIter1, *SNIter2))
			{
				delpair = true;
				similarnodes.push_back(std::make_pair(*SNIter1, *SNIter2));
			}
			else continue;

		}
			//similarnodes.push_back(std::make_pair(*SNIter1, *SNIter2));
			//delete children pairs
		child = (*SNIter1)->getChildren();
		if (delpair)
		{
			for (auto first : child)
				DeletePair(first);
			delpair = false;
		}
				
	}


}
Exemple #3
0
 BaseMesh* FixedPlaneMesh::ToBaseMesh() 
 {
     std::vector<Point3D> pts; 
     ListOfvertices results;
     BaseMesh* pMesh = new BaseMesh;
     pMesh->SetTransformedAABB(AABB());
	//auto center = AABB().Center();
	//auto scale = AABB().Diagonal();

     for (int i = 0 ; i < mPolygons.size(); i++)
     {
        for (int j = 0 ; j < mPolygons[i].bplanes.size(); j++)
        {
            int prevPtIdx = j == 0? mPolygons[i].bplanes.size() -1 : j -1;
			Point3D pt = InexactComputePoint(mPolygons[i].splane, mPolygons[i].bplanes[prevPtIdx], mPolygons[i].bplanes[j] );
			//pt = denormalize(pt, center, scale);
			if (!pts.size() || 
				!IsSimilar(pt, pts.back())) 
				pts.push_back(pt);
        }
        auto normal = normalize(mPolygons[i].splane.Normal());
		TrianglatePolygon(normal, pts, results);
		//catch (...){
		//	wchar_t ch[64];
		//	swprintf(ch, 64, L"Error, %u", i);
		//	OutputDebugString(ch);
		//	results.clear();
		//}

        for (int k = 0 ; k < results.size(); k+=3)
        {   
            pMesh->Add(results[k], results[k+1], results[k+2], normal);
        }
        pts.clear();
		results.clear();
     }
     pMesh->GenID();
     return pMesh;
 }
Exemple #4
0
static picture_t *FilterPacked( filter_t *p_filter, picture_t *p_pic )
{
    picture_t *p_outpic;
    filter_sys_t *p_sys = p_filter->p_sys;
    int i_simthres = atomic_load( &p_sys->i_simthres );
    int i_satthres = atomic_load( &p_sys->i_satthres );
    int i_color = atomic_load( &p_sys->i_color );

    if( !p_pic ) return NULL;

    p_outpic = filter_NewPicture( p_filter );
    if( !p_outpic )
    {
        picture_Release( p_pic );
        return NULL;
    }

    int i_y_offset, i_u_offset, i_v_offset;
    int i_ret = GetPackedYuvOffsets( p_filter->fmt_in.video.i_chroma,
                                     &i_y_offset, &i_u_offset, &i_v_offset );
    if( i_ret == VLC_EGENERIC )
    {
        picture_Release( p_pic );
        return NULL;
    }

    /*
     * Copy Y and do the U and V planes
     */
    int refu, refv, reflength;
    GetReference( &refu, &refv, &reflength, i_color );

    for( int y = 0; y < p_pic->p->i_visible_lines; y++ )
    {
        uint8_t *p_src = &p_pic->p->p_pixels[y * p_pic->p->i_pitch];
        uint8_t *p_dst = &p_outpic->p->p_pixels[y * p_outpic->p->i_pitch];

        for( int x = 0; x < p_pic->p->i_visible_pitch / 4; x++ )
        {
            p_dst[i_y_offset + 0] = p_src[i_y_offset + 0];
            p_dst[i_y_offset + 2] = p_src[i_y_offset + 2];

            if( IsSimilar( p_src[i_u_offset] - 0x80, p_src[i_v_offset] - 0x80,
                           refu, refv, reflength,
                           i_satthres, i_simthres ) )
            {
                p_dst[i_u_offset] = p_src[i_u_offset];
                p_dst[i_v_offset] = p_src[i_v_offset];
            }
            else
            {
                p_dst[i_u_offset] = 0x80;
                p_dst[i_v_offset] = 0x80;
            }

            p_dst += 4;
            p_src += 4;
        }
    }

    return CopyInfoAndRelease( p_outpic, p_pic );
}