diff --git a/vcg/container/derivation_chain.h b/vcg/container/derivation_chain.h
index 3697a4da..07fe4a2d 100644
--- a/vcg/container/derivation_chain.h
+++ b/vcg/container/derivation_chain.h
@@ -99,6 +99,27 @@ template <template <typename,typename,typename,typename>
 					template <typename> class I, template <typename> class J>
           class Arity10: public J<Arity9<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I > > {};
 
+template <template <typename,typename,typename,typename>
+          class Base,class BVT, class BET, typename BFT,class BTT,
+          template <typename> class A, template <typename> class B, 
+          template <typename> class C, template <typename> class D,
+          template <typename> class E, template <typename> class F,
+          template <typename> class G, template <typename> class H,
+          template <typename> class I, template <typename> class J,
+          template <typename> class K>
+          class Arity11: public K<Arity10<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J> > {};
+
+
+template <template <typename,typename,typename,typename>
+          class Base,class BVT, class BET, typename BFT,class BTT,
+          template <typename> class A, template <typename> class B, 
+          template <typename> class C, template <typename> class D,
+          template <typename> class E, template <typename> class F,
+          template <typename> class G, template <typename> class H,
+          template <typename> class I, template <typename> class J,
+          template <typename> class K, template <typename> class L>
+          class Arity12: public L<Arity11<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K> > {};
+
 template < typename T=int>
 class DefaultDeriver : public T {};
 class DumClass {};
diff --git a/vcg/simplex/vertexplus/base.h b/vcg/simplex/vertexplus/base.h
index ea0beaff..4db9d6d8 100644
--- a/vcg/simplex/vertexplus/base.h
+++ b/vcg/simplex/vertexplus/base.h
@@ -137,13 +137,13 @@ I.e. IsD() that uses the overridden Flags() member must be defined here.
 */
 
 template <class BVT, class BET, typename BFT,class BTT,
-          template <typename> class A, template <typename> class B, 
-          template <typename> class C, template <typename> class D, 
+          template <typename> class A, template <typename> class B,
+          template <typename> class C, template <typename> class D,
           template <typename> class E, template <typename> class F,
           template <typename> class G, template <typename> class H,
-					template <typename> class I, template <typename> class J, 
-					template <typename> class K> 
-class VertexArityMax: public K<Arity10<VertexBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J> > {
+					template <typename> class I, template <typename> class J,
+					template <typename> class K, template <typename> class L> 
+class VertexArityMax: public Arity12<VertexBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K, L> {
 
 // ----- Flags stuff -----
 public:
@@ -159,7 +159,7 @@ public:
 		SELECTED   = 0x0020,		// This bit can be used to select 
 		BORDER     = 0x0100,    // Border Flag
 		USER0      = 0x0200			// First user bit
-			};
+  };
 
 	inline int & UberFlags () { return this->Flags();	}
 	inline const int UberFlags() const 	{		return this->Flags();	}
@@ -267,8 +267,8 @@ template <class BVT, class BET, class BFT, class BTT,
           template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
           template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
 					template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
-					template <typename> class K = DefaultDeriver> 
-              class VertexSimp3: public VertexArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K>  {};
+					template <typename> class K = DefaultDeriver, template <typename> class L = DefaultDeriver>
+              class VertexSimp3: public VertexArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K, L>  {};
 
 template <class BVT, class BET, class BFT, 
           template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
@@ -276,8 +276,8 @@ template <class BVT, class BET, class BFT,
           template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
           template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
 					template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
-					template <typename> class K = DefaultDeriver> 
-              class VertexSimp2: public VertexArityMax<BVT,BET,BFT,DumClass, A, B, C, D, E, F, G, H, I, J, K>  {};
+					template <typename> class K = DefaultDeriver, template <typename> class L = DefaultDeriver>
+              class VertexSimp2: public VertexArityMax<BVT,BET,BFT,DumClass, A, B, C, D, E, F, G, H, I, J, K, L>  {};
 
 template <class BVT, class BET, 
           template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
@@ -285,8 +285,8 @@ template <class BVT, class BET,
           template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
           template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
 					template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
-					template <typename> class K = DefaultDeriver> 
-                class VertexSimp1: public VertexArityMax<BVT,BET,DumClass,DumClass, A, B, C, D, E, F, G, H, I, J, K>  {};
+					template <typename> class K = DefaultDeriver, template <typename> class L = DefaultDeriver> 
+                class VertexSimp1: public VertexArityMax<BVT,BET,DumClass,DumClass, A, B, C, D, E, F, G, H, I, J, K, L>  {};
 
 }// end namespace
 #endif
diff --git a/vcg/simplex/vertexplus/component_occ.h b/vcg/simplex/vertexplus/component_occ.h
index a0ca9f75..a5e1e96a 100644
--- a/vcg/simplex/vertexplus/component_occ.h
+++ b/vcg/simplex/vertexplus/component_occ.h
@@ -218,6 +218,37 @@ template <class T> class CurvatureDirdOcc: public CurvatureDirOcc<CurvatureDirTy
 public:	static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDird"));T::Name(name);}
 };
 
+/*-------------------------- RADIUS ----------------------------------*/
+
+template <class A, class TT> class RadiusOcc: public TT {
+public:
+  typedef A RadiusType;
+  typedef A ScalarType;
+  typedef typename TT::VertType VertType;
+
+  RadiusType  &R(){  return CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this);}
+  const RadiusType &cR() const { return CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this);}
+
+  template <class LeftV>
+  void ImportLocal(const LeftV & leftV){
+    CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this) = leftV.cR();
+    TT::ImporLocal(leftV);
+  }
+
+  static bool HasRadius()     { return true; }
+  static bool HasRadiusOcc()  { return true; }
+  static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusOcc"));TT::Name(name);}
+
+private:   
+};
+
+template <class T> class RadiusfOcc: public RadiusOcc<float, T> {
+  static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusfOcc"));T::Name(name);}
+};
+template <class T> class RadiusdOcc: public RadiusOcc<double, T> {
+  static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusdOcc"));T::Name(name);}
+};
+
 ///*----------------------------- VFADJ ------------------------------*/ 
 
 template <class T> class VFAdjOcc: public T {
diff --git a/vcg/simplex/vertexplus/component_ocf.h b/vcg/simplex/vertexplus/component_ocf.h
index 211c79db..32735465 100644
--- a/vcg/simplex/vertexplus/component_ocf.h
+++ b/vcg/simplex/vertexplus/component_ocf.h
@@ -8,7 +8,7 @@
 *                                                                    \      *
 * All rights reserved.                                                      *
 *                                                                           *
-* This program is free software; you can redistribute it and/or modify      *   
+* This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the GNU General Public License as published by      *
 * the Free Software Foundation; either version 2 of the License, or         *
 * (at your option) any later version.                                       *
@@ -21,7 +21,7 @@
 *                                                                           *
 ****************************************************************************/
 /****************************************************************************
-  History
+	History
 
 $Log: not supported by cvs2svn $
 Revision 1.16  2008/04/03 23:15:40  cignoni
@@ -80,7 +80,7 @@ First Really Working version
 
 ****************************************************************************/
 
-/* 
+/*
 Note
 OCF = Optional Component Fast (hopefully)
 compare with OCC(Optional Component Compact)
@@ -97,77 +97,81 @@ Mainly the trick here is to store a base pointer in each simplex...
 #include <limits>
 
 namespace vcg {
-  namespace vertex {
+	namespace vertex {
 /*
 All the Components that can be added to a vertex should be defined in the namespace vert:
 
 */
 template <class VALUE_TYPE>
 class vector_ocf: public std::vector<VALUE_TYPE> {
-  typedef std::vector<VALUE_TYPE> BaseType; 
+	typedef std::vector<VALUE_TYPE> BaseType;
 	typedef typename vector_ocf<VALUE_TYPE>::iterator ThisTypeIterator;
-  
+
 public:
 	vector_ocf():std::vector<VALUE_TYPE>(){
-  QualityEnabled=false;
-  ColorEnabled=false;
-  MarkEnabled = false;
-  NormalEnabled=false;
-  VFAdjacencyEnabled=false;
-	CurvatureEnabled = false;
-	CurvatureEnabled= false;
-	CurvatureDirEnabled= false;
+		QualityEnabled = false;
+		ColorEnabled = false;
+		MarkEnabled = false;
+		NormalEnabled = false;
+		VFAdjacencyEnabled = false;
+		CurvatureEnabled = false;
+		CurvatureEnabled = false;
+		CurvatureDirEnabled = false;
+		RadiusEnabled = false;
 	}
-  
-  // override di tutte le funzioni che possono spostare 
+
+	// override di tutte le funzioni che possono spostare
 	// l'allocazione in memoria del container
 	void push_back(const VALUE_TYPE & v)
-  {
-    BaseType::push_back(v);
-	  BaseType::back()._ovp = this;
-		if (ColorEnabled)       CV.push_back(vcg::Color4b(vcg::Color4b::White));
-    if (MarkEnabled)        MV.push_back(0);
-    if (NormalEnabled)      NV.push_back(typename VALUE_TYPE::NormalType());
-    if (VFAdjacencyEnabled) AV.push_back(VFAdjType());		
-    if (CurvatureEnabled)   CuV.push_back(typename VALUE_TYPE::CurvatureType());		
-    if (CurvatureDirEnabled) CuDV.push_back(typename VALUE_TYPE::CurvatureDirType());		
-  }
+	{
+		BaseType::push_back(v);
+		BaseType::back()._ovp = this;
+		if (ColorEnabled)         CV.push_back(vcg::Color4b(vcg::Color4b::White));
+		if (MarkEnabled)          MV.push_back(0);
+		if (NormalEnabled)        NV.push_back(typename VALUE_TYPE::NormalType());
+		if (VFAdjacencyEnabled)   AV.push_back(VFAdjType());
+		if (CurvatureEnabled)     CuV.push_back(typename VALUE_TYPE::CurvatureType());
+		if (CurvatureDirEnabled)  CuDV.push_back(typename VALUE_TYPE::CurvatureDirType());
+		if (RadiusEnabled)        RadiusV.push_back(typename VALUE_TYPE::RadiusType());
+	}
 	void pop_back();
-  void resize(const unsigned int & _size) 
-  {
+	void resize(const unsigned int & _size)
+	{
 		const unsigned int oldsize = BaseType::size();
 			BaseType::resize(_size);
 		if(oldsize<_size){
 			ThisTypeIterator firstnew = BaseType::begin();
 			advance(firstnew,oldsize);
 			_updateOVP(firstnew,(*this).end());
-		}  
-		if (ColorEnabled) CV.resize(_size);
-    if (MarkEnabled)        MV.resize(_size);
-    if (NormalEnabled) NV.resize(_size);
-    if (VFAdjacencyEnabled) AV.resize(_size);
-    if (CurvatureEnabled)   CuV.resize(_size);		
-    if (CurvatureDirEnabled) CuDV.resize(_size);		
-   }
-  
+		}
+		if (ColorEnabled)         CV.resize(_size);
+		if (MarkEnabled)          MV.resize(_size);
+		if (NormalEnabled)        NV.resize(_size);
+		if (VFAdjacencyEnabled)   AV.resize(_size);
+		if (CurvatureEnabled)     CuV.resize(_size);
+		if (CurvatureDirEnabled)  CuDV.resize(_size);
+		if (RadiusEnabled)        RadiusV.resize(_size);
+	}
+
 	void reserve(const unsigned int & _size)
-  {
-    BaseType::reserve(_size);
-    if (ColorEnabled)				 CV.reserve(_size);
-    if (MarkEnabled)         MV.reserve(_size);
-    if (NormalEnabled)			 NV.reserve(_size);
+	{
+		BaseType::reserve(_size);
+		if (ColorEnabled)				 CV.reserve(_size);
+		if (MarkEnabled)         MV.reserve(_size);
+		if (NormalEnabled)			 NV.reserve(_size);
 		if (VFAdjacencyEnabled)  AV.reserve(_size);
-    if (CurvatureEnabled)    CuV.reserve(_size);		
-    if (CurvatureDirEnabled) CuDV.reserve(_size);		
-  }
+		if (CurvatureEnabled)    CuV.reserve(_size);
+		if (CurvatureDirEnabled) CuDV.reserve(_size);
+		if (RadiusEnabled)       RadiusV.reserve(_size);
+	}
 
 	void _updateOVP(ThisTypeIterator lbegin, ThisTypeIterator lend)
 	{
-    ThisTypeIterator vi;
-    for(vi=lbegin;vi!=lend;++vi)
-        (*vi)._ovp=this;
+		ThisTypeIterator vi;
+		for(vi=lbegin;vi!=lend;++vi)
+				(*vi)._ovp=this;
 	}
- 
+
 // this function is called by the specialized Reorder function, that is called whenever someone call the allocator::CompactVertVector
 void ReorderVert(std::vector<size_t> &newVertIndex )
 {
@@ -178,27 +182,30 @@ void ReorderVert(std::vector<size_t> &newVertIndex )
 	if (VFAdjacencyEnabled) assert( AV.size() == newVertIndex.size() );
 	if (CurvatureEnabled)   assert(CuV.size() == newVertIndex.size() );
 	if (CurvatureDirEnabled)assert(CuDV.size() == newVertIndex.size() );
-		
+	assert( (!RadiusEnabled) || RadiusV.size() == newVertIndex.size() );
+
 	for(i=0;i<newVertIndex.size();++i)
 		{
 			if(newVertIndex[i] != std::numeric_limits<size_t>::max() )
 				{
 					assert(newVertIndex[i] <= i);
-					if (ColorEnabled)			     CV[newVertIndex[i]] =  CV[i];
-					if (MarkEnabled)				   MV[newVertIndex[i]] =  MV[i];
-					if (NormalEnabled)         NV[newVertIndex[i]] =  NV[i];
-					if (VFAdjacencyEnabled)    AV[newVertIndex[i]] =  AV[i];
+					if (ColorEnabled)			    CV[newVertIndex[i]] =  CV[i];
+					if (MarkEnabled)				  MV[newVertIndex[i]] =  MV[i];
+					if (NormalEnabled)        NV[newVertIndex[i]] =  NV[i];
+					if (VFAdjacencyEnabled)   AV[newVertIndex[i]] =  AV[i];
 					if (CurvatureEnabled)     CuV[newVertIndex[i]] = CuV[i];
-					if (CurvatureDirEnabled) CuDV[newVertIndex[i]] =CuDV[i];
+					if (CurvatureDirEnabled)  CuDV[newVertIndex[i]] =CuDV[i];
+					if (RadiusEnabled)        RadiusV[newVertIndex[i]] = RadiusV[i];
 				}
 		}
-		
-	if (ColorEnabled)          CV.resize(BaseType::size());
-	if (MarkEnabled)           MV.resize(BaseType::size());
-	if (NormalEnabled)         NV.resize(BaseType::size());
-	if (VFAdjacencyEnabled)    AV.resize(BaseType::size());
+
+	if (ColorEnabled)         CV.resize(BaseType::size());
+	if (MarkEnabled)          MV.resize(BaseType::size());
+	if (NormalEnabled)        NV.resize(BaseType::size());
+	if (VFAdjacencyEnabled)   AV.resize(BaseType::size());
 	if (CurvatureEnabled)     CuV.resize(BaseType::size());
-	if (CurvatureDirEnabled) CuDV.resize(BaseType::size());
+	if (CurvatureDirEnabled)  CuDV.resize(BaseType::size());
+	if (RadiusEnabled)  RadiusV.resize(BaseType::size());
 }
 
 
@@ -208,177 +215,189 @@ void ReorderVert(std::vector<size_t> &newVertIndex )
 
 bool IsQualityEnabled() const {return QualityEnabled;}
 void EnableQuality() {
-  assert(VALUE_TYPE::HasQualityOcf());
-  QualityEnabled=true;
-  QV.resize((*this).size());
+	assert(VALUE_TYPE::HasQualityOcf());
+	QualityEnabled=true;
+	QV.resize((*this).size());
 }
 
 void DisableQuality() {
-  assert(VALUE_TYPE::HasQualityOcf());
-  QualityEnabled=false;
-  QV.clear();
+	assert(VALUE_TYPE::HasQualityOcf());
+	QualityEnabled=false;
+	QV.clear();
 }
 
 bool IsColorEnabled() const {return ColorEnabled;}
 void EnableColor() {
-  assert(VALUE_TYPE::HasColorOcf());
-  ColorEnabled=true;
-  CV.resize((*this).size());
+	assert(VALUE_TYPE::HasColorOcf());
+	ColorEnabled=true;
+	CV.resize((*this).size());
 }
 
 void DisableColor() {
-  assert(VALUE_TYPE::HasColorOcf());
-  ColorEnabled=false;
-  CV.clear();
+	assert(VALUE_TYPE::HasColorOcf());
+	ColorEnabled=false;
+	CV.clear();
 }
 
 bool IsMarkEnabled() const {return MarkEnabled;}
 void EnableMark() {
-  assert(VALUE_TYPE::HasFaceMarkOcf());
-  MarkEnabled=true;
-  MV.resize((*this).size());
+	assert(VALUE_TYPE::HasFaceMarkOcf());
+	MarkEnabled=true;
+	MV.resize((*this).size());
 }
 
 void DisableMark() {
-  assert(VALUE_TYPE::HasFaceMarkOcf());
-  MarkEnabled=false;
-  MV.clear();
+	assert(VALUE_TYPE::HasFaceMarkOcf());
+	MarkEnabled=false;
+	MV.clear();
 }
 
 bool IsNormalEnabled() const {return NormalEnabled;}
 void EnableNormal() {
-  assert(VALUE_TYPE::HasNormalOcf());
-  NormalEnabled=true;
-  NV.resize((*this).size());
+	assert(VALUE_TYPE::HasNormalOcf());
+	NormalEnabled=true;
+	NV.resize((*this).size());
 }
 
 void DisableNormal() {
-  assert(VALUE_TYPE::HasNormalOcf());
-  NormalEnabled=false;
-  NV.clear();
+	assert(VALUE_TYPE::HasNormalOcf());
+	NormalEnabled=false;
+	NV.clear();
 }
-  
+
 void EnableVFAdjacency() {
-  assert(VALUE_TYPE::HasVFAdjacencyOcf());
-  VFAdjacencyEnabled=true;
-  AV.resize((*this).size());
+	assert(VALUE_TYPE::HasVFAdjacencyOcf());
+	VFAdjacencyEnabled=true;
+	AV.resize((*this).size());
 }
 
 void DisableVFAdjacency() {
-  assert(VALUE_TYPE::HasVFAdjacencyOcf());
-  VFAdjacencyEnabled=false;
-  AV.clear();
+	assert(VALUE_TYPE::HasVFAdjacencyOcf());
+	VFAdjacencyEnabled=false;
+	AV.clear();
 }
 
- 
+
 void EnableCurvature() {
-  assert(VALUE_TYPE::HasCurvatureOcf());
-  CurvatureEnabled=true;
-  CuV.resize((*this).size());
+	assert(VALUE_TYPE::HasCurvatureOcf());
+	CurvatureEnabled=true;
+	CuV.resize((*this).size());
 }
 
 void DisableCurvature() {
-  assert(VALUE_TYPE::HasCurvatureOcf());
-  CurvatureEnabled=false;
-  CuV.clear();
+	assert(VALUE_TYPE::HasCurvatureOcf());
+	CurvatureEnabled=false;
+	CuV.clear();
 }
 
 void EnableCurvatureDir() {
-  assert(VALUE_TYPE::HasCurvatureDirOcf());
-  CurvatureDirEnabled=true;
-  CuDV.resize((*this).size());
+	assert(VALUE_TYPE::HasCurvatureDirOcf());
+	CurvatureDirEnabled=true;
+	CuDV.resize((*this).size());
 }
 
 void DisableCurvatureDir() {
-  assert(VALUE_TYPE::HasCurvatureDirOcf());
-  CurvatureDirEnabled=false;
-  CuDV.clear();
+	assert(VALUE_TYPE::HasCurvatureDirOcf());
+	CurvatureDirEnabled=false;
+	CuDV.clear();
 }
 
+void EnableRadius() {
+	assert(VALUE_TYPE::HasRadiusOcf());
+	RadiusEnabled=true;
+	RadiusV.resize((*this).size());
+}
 
+void DisableRadius() {
+	assert(VALUE_TYPE::HasRadiusOcf());
+	RadiusEnabled=false;
+	RadiusV.clear();
+}
 
 struct VFAdjType {
-  typename VALUE_TYPE::FacePointer _fp ;    
-  int _zp ;    
-  };
-  
+	typename VALUE_TYPE::FacePointer _fp ;
+	int _zp ;
+	};
+
 public:
-  std::vector<typename VALUE_TYPE::QualityType> QV;
-  std::vector<typename VALUE_TYPE::CurvatureType> CuV;
-  std::vector<typename VALUE_TYPE::CurvatureDirType> CuDV;
-  std::vector<typename VALUE_TYPE::ColorType> CV;
-  std::vector<typename VALUE_TYPE::NormalType> NV;
-  std::vector<struct VFAdjType> AV;
-  std::vector<int> MV;
-	
-  bool QualityEnabled;
-  bool ColorEnabled;
-  bool NormalEnabled;
-  bool VFAdjacencyEnabled;
-  bool CurvatureEnabled;
-  bool CurvatureDirEnabled;
+	std::vector<typename VALUE_TYPE::QualityType> QV;
+	std::vector<typename VALUE_TYPE::CurvatureType> CuV;
+	std::vector<typename VALUE_TYPE::CurvatureDirType> CuDV;
+	std::vector<typename VALUE_TYPE::RadiusType> RadiusV;
+	std::vector<typename VALUE_TYPE::ColorType> CV;
+	std::vector<typename VALUE_TYPE::NormalType> NV;
+	std::vector<struct VFAdjType> AV;
+	std::vector<int> MV;
+
+	bool QualityEnabled;
+	bool ColorEnabled;
+	bool NormalEnabled;
+	bool VFAdjacencyEnabled;
+	bool CurvatureEnabled;
+	bool CurvatureDirEnabled;
 	bool MarkEnabled;
+	bool RadiusEnabled;
 };
 
 
 //template<>	void EnableAttribute<typename VALUE_TYPE::NormalType>(){	NormalEnabled=true;}
 
-/*------------------------- COORD -----------------------------------------*/ 
-/*----------------------------- VFADJ ------------------------------*/ 
+/*------------------------- COORD -----------------------------------------*/
+/*----------------------------- VFADJ ------------------------------*/
 
 
 template <class T> class VFAdjOcf: public T {
 public:
-  typename T::FacePointer &VFp() {
-    assert((*this).Base().VFAdjacencyEnabled); 
-    return (*this).Base().AV[(*this).Index()]._fp; 
-  }
+	typename T::FacePointer &VFp() {
+		assert((*this).Base().VFAdjacencyEnabled);
+		return (*this).Base().AV[(*this).Index()]._fp;
+	}
 
-  typename T::FacePointer cVFp() const {
-    if(! (*this).Base().VFAdjacencyEnabled ) return 0; 
-    else return (*this).Base().AV[(*this).Index()]._fp; 
-  }
+	typename T::FacePointer cVFp() const {
+		if(! (*this).Base().VFAdjacencyEnabled ) return 0;
+		else return (*this).Base().AV[(*this).Index()]._fp;
+	}
 
-  int &VFi() {
-    assert((*this).Base().VFAdjacencyEnabled); 
-    return (*this).Base().AV[(*this).Index()]._zp; 
-  }
+	int &VFi() {
+		assert((*this).Base().VFAdjacencyEnabled);
+		return (*this).Base().AV[(*this).Index()]._zp;
+	}
 	template <class LeftV>
-	void ImportLocal(const LeftV & leftV) 
+	void ImportLocal(const LeftV & leftV)
 	{
 		if((*this).Base().VFAdjacencyEnabled) // init the data only if they are enabled!
-			{ 
-				VFp() = NULL; 
-				VFi() = -1; 
-			} 
+			{
+				VFp() = NULL;
+				VFi() = -1;
+			}
 		T::ImportLocal(leftV);
 	}
 
-  static bool HasVFAdjacency()   {   return true; }
-  static bool HasVFAdjacencyOcf()   {assert(!T::HasVFAdjacencyOcf()); return true; }
+	static bool HasVFAdjacency()   {   return true; }
+	static bool HasVFAdjacencyOcf()   {assert(!T::HasVFAdjacencyOcf()); return true; }
 
 private:
 };
 
-/*------------------------- Normal -----------------------------------------*/ 
+/*------------------------- Normal -----------------------------------------*/
 
 template <class A, class T> class NormalOcf: public T {
 public:
-  typedef A NormalType;
-  static bool HasNormal()   { return true; }
-  static bool HasNormalOcf()   { return true; }
+	typedef A NormalType;
+	static bool HasNormal()   { return true; }
+	static bool HasNormalOcf()   { return true; }
 
-  NormalType &N() { 
-    // you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal()
-    assert((*this).Base().NormalEnabled); 
-    return (*this).Base().NV[(*this).Index()];  }
-  const NormalType &N() const { 
-    // you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal()
-    assert((*this).Base().NormalEnabled); 
-    return (*this).Base().NV[(*this).Index()];  }
+	NormalType &N() {
+		// you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal()
+		assert((*this).Base().NormalEnabled);
+		return (*this).Base().NV[(*this).Index()];  }
+	const NormalType &N() const {
+		// you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal()
+		assert((*this).Base().NormalEnabled);
+		return (*this).Base().NV[(*this).Index()];  }
 
 	template <class LeftV>
-	void ImportLocal(const LeftV & leftV){ 
+	void ImportLocal(const LeftV & leftV){
 			if((*this).Base().NormalEnabled && leftV.Base().NormalEnabled ) // copy the data only if they are enabled in both vertices
 				N().Import(leftV.cN());
 			T::ImporLocal(leftV);}
@@ -388,78 +407,78 @@ template <class T> class Normal3sOcf: public NormalOcf<vcg::Point3s, T> {};
 template <class T> class Normal3fOcf: public NormalOcf<vcg::Point3f, T> {};
 template <class T> class Normal3dOcf: public NormalOcf<vcg::Point3d, T> {};
 
-///*-------------------------- COLOR ----------------------------------*/ 
+///*-------------------------- COLOR ----------------------------------*/
 
 template <class A, class T> class ColorOcf: public T {
 public:
-  typedef A ColorType;
-  ColorType &C() { assert((*this).Base().NormalEnabled); return (*this).Base().CV[(*this).Index()]; }
-  const ColorType &cC() const { assert((*this).Base().ColorEnabled); return (*this).Base().CV[(*this).Index()]; }
+	typedef A ColorType;
+	ColorType &C() { assert((*this).Base().NormalEnabled); return (*this).Base().CV[(*this).Index()]; }
+	const ColorType &cC() const { assert((*this).Base().ColorEnabled); return (*this).Base().CV[(*this).Index()]; }
 	template <class LeftV>
 	void ImportLocal(const LeftV & leftV)
-		{			
+		{
 			if((*this).Base().ColorEnabled && leftV.Base().ColorEnabled ) // copy the data only if they are enabled in both vertices
-					C() = leftV.cC(); 
+					C() = leftV.cC();
 			T::ImporLocal(leftV);
 		}
-	
-  static bool HasColor()   { return true; }
-  static bool HasColorOcf()   { assert(!T::HasColorOcf()); return true; }
+
+	static bool HasColor()   { return true; }
+	static bool HasColorOcf()   { assert(!T::HasColorOcf()); return true; }
 };
 
 template <class T> class Color4bOcf: public ColorOcf<vcg::Color4b, T> {};
 
-///*-------------------------- QUALITY  ----------------------------------*/ 
+///*-------------------------- QUALITY  ----------------------------------*/
 
 template <class A, class T> class QualityOcf: public T {
 public:
-  typedef A QualityType;
-  QualityType &Q() { assert((*this).Base().QualityEnabled); return (*this).Base().QV[(*this).Index()]; }
+	typedef A QualityType;
+	QualityType &Q() { assert((*this).Base().QualityEnabled); return (*this).Base().QV[(*this).Index()]; }
 	template <class LeftV>
 	void ImportLocal(const LeftV & leftV)
-		{ 
+		{
 			if((*this).Base().QualityEnabled && leftV.Base().QualityEnabled ) // copy the data only if they are enabled in both vertices
 						Q() = leftV.cQ();
 			T::ImporLocal(leftV);
 		}
-  static bool HasQuality()   { return true; }
-  static bool HasQualityOcf()   { assert(!T::HasQualityOcf()); return true; }
+	static bool HasQuality()   { return true; }
+	static bool HasQualityOcf()   { assert(!T::HasQualityOcf()); return true; }
 };
 
 template <class T> class QualityfOcf: public QualityOcf<float, T> {};
 
-///*-------------------------- MARK  ----------------------------------*/ 
+///*-------------------------- MARK  ----------------------------------*/
 
 template <class T> class MarkOcf: public T {
 public:
-  inline int & IMark()       { 
-    assert((*this).Base().MarkEnabled); 
-    return (*this).Base().MV[(*this).Index()]; 
-  }
- 
-  inline int IMark() const   { 
-    assert((*this).Base().MarkEnabled); 
-    return (*this).Base().MV[(*this).Index()]; 
-  } ;
+	inline int & IMark()       {
+		assert((*this).Base().MarkEnabled);
+		return (*this).Base().MV[(*this).Index()];
+	}
+
+	inline int IMark() const   {
+		assert((*this).Base().MarkEnabled);
+		return (*this).Base().MV[(*this).Index()];
+	}
 
 	template <class LeftV>
 	void ImportLocal(const LeftV & leftV)
 	{
 		if((*this).Base().MarkEnabled && leftV.Base().MarkEnabled ) // copy the data only if they are enabled in both vertices
-				IMark() = leftV.IMark(); 
+				IMark() = leftV.IMark();
 		T::ImportLocal(leftV);
 	}
-  static bool HasFaceMark()   { return true; }
-  static bool HasFaceMarkOcf()   { return true; }
-  inline void InitIMark()    { IMark() = 0; }
+	static bool HasFaceMark()   { return true; }
+	static bool HasFaceMarkOcf()   { return true; }
+	inline void InitIMark()    { IMark() = 0; }
 };
 
 
-///*-------------------------- CURVATURE  ----------------------------------*/ 
+///*-------------------------- CURVATURE  ----------------------------------*/
 
 template <class A, class TT> class CurvatureOcf: public TT {
 public:
-  typedef Point2<A> CurvatureType;
+	typedef Point2<A> CurvatureType;
 	typedef typename CurvatureType::ScalarType ScalarType;
 
 	ScalarType  &Kh(){  assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][0];}
@@ -467,41 +486,41 @@ public:
 	const ScalarType &cKh() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][0];}
 	const ScalarType &cKg() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][1];}
 
- 	template <class LeftV>
-	void ImportLocal(const LeftV & leftV){ 
-			if((*this).Base().CurvatureEnabled && leftV.Base().CurvatureEnabled ) // copy the data only if they are enabled in both vertices
-				{
-					(*this).Base().CuV[(*this).Index()][0] = leftV.cKh();
-					(*this).Base().CuV[(*this).Index()][1] = leftV.cKg();
-				}
-			TT::ImportLocal(leftV);
+	template <class LeftV>
+	void ImportLocal(const LeftV & leftV){
+		if((*this).Base().CurvatureEnabled && leftV.Base().CurvatureEnabled ) // copy the data only if they are enabled in both vertices
+			{
+				(*this).Base().CuV[(*this).Index()][0] = leftV.cKh();
+				(*this).Base().CuV[(*this).Index()][1] = leftV.cKg();
+			}
+		TT::ImportLocal(leftV);
 	}
 
 	static bool HasCurvatureOcf()   { return true; }
 	static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureOcf"));TT::Name(name);}
 
-private:   
+private:
 };
 
 template <class T> class CurvaturefOcf: public CurvatureOcf<float, T> {};
 template <class T> class CurvaturedOcf: public CurvatureOcf<double, T> {};
 
 
-///*-------------------------- CURVATURE DIR ----------------------------------*/ 
+///*-------------------------- CURVATURE DIR ----------------------------------*/
 
 template <class S>
 struct CurvatureDirTypeOcf{
 	typedef Point3<S> VecType;
 	typedef  S   ScalarType;
 	CurvatureDirTypeOcf () {}
-	Point3<S>max_dir,min_dir; 
+	Point3<S>max_dir,min_dir;
 	S k1,k2;
 };
 
 
 template <class A, class TT> class CurvatureDirOcf: public TT {
 public:
-  typedef A CurvatureDirType;
+	typedef A CurvatureDirType;
 	typedef typename CurvatureDirType::VecType VecType;
 	typedef typename CurvatureDirType::ScalarType ScalarType;
 
@@ -515,11 +534,11 @@ public:
 	const ScalarType &cK1() const {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k1;}
 	const ScalarType &cK2()const  {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k2;}
 
-  static bool HasCurvatureDirOcf()   { return true; }
+	static bool HasCurvatureDirOcf()   { return true; }
 	static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDirOcf"));TT::Name(name);}
 
 private:
-  CurvatureDirType _curv;    
+	CurvatureDirType _curv;
 };
 
 
@@ -529,19 +548,50 @@ public:	static void Name(std::vector<std::string> & name){name.push_back(std::st
 template <class T> class CurvatureDirdOcf: public CurvatureDirOcf<CurvatureDirTypeOcf<double>, T> {
 public:	static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDirdOcf"));T::Name(name);}
 };
-///*-------------------------- InfoOpt  ----------------------------------*/ 
+
+
+///*-------------------------- RADIUS  ----------------------------------*/
+
+template <class A, class TT> class RadiusOcf: public TT {
+public:
+	typedef A RadiusType;
+	typedef RadiusType ScalarType;
+
+	RadiusType  &R(){  assert((*this).Base().RadiusEnabled); return (*this).Base().RadiusV[(*this).Index()];}
+	const RadiusType &cR() const { assert((*this).Base().RadiusEnabled); return (*this).Base().RadiusV[(*this).Index()];}
+
+	template <class LeftV>
+	void ImportLocal(const LeftV & leftV)
+	{
+		if ((*this).Base().RadiusEnabled && leftV.Base().RadiusEnabled )
+			(*this).Base().RadiusV[(*this).Index()] = leftV.cR();
+		TT::ImportLocal(leftV);
+	}
+
+	static bool HasRadius()     { return true; }
+	static bool HasRadiusOcf()  { return true; }
+	static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusOcf")); TT::Name(name);}
+
+private:
+};
+
+template <class T> class RadiusfOcf: public RadiusOcf<float, T> {};
+template <class T> class RadiusdOcf: public RadiusOcf<double, T> {};
+
+
+///*-------------------------- InfoOpt  ----------------------------------*/
 
 template < class T> class InfoOcf: public T {
 public:
-  vector_ocf<typename T::VertType> &Base() const { return *_ovp;}
+	vector_ocf<typename T::VertType> &Base() const { return *_ovp;}
 
-  inline int Index() const {
-    typename  T::VertType const *tp=static_cast<typename T::VertType const*>(this); 
-    int tt2=tp- &*(_ovp->begin());
-    return tt2;
-  } 
+	inline int Index() const {
+		typename  T::VertType const *tp=static_cast<typename T::VertType const*>(this);
+		int tt2=tp- &*(_ovp->begin());
+		return tt2;
+	}
 public:
-  vector_ocf<typename T::VertType> *_ovp;
+	vector_ocf<typename T::VertType> *_ovp;
 
 	static bool HasQualityOcf()   { return false; }
 	static bool HasVFAdjacencyOcf()   { return false; }
@@ -557,10 +607,10 @@ namespace tri
 	template < class, class > class TriMesh;
 
 	template < class VertexType, class FaceContainerType >
-    bool HasPerVertexQuality (const TriMesh < vertex::vector_ocf< VertexType > , FaceContainerType > & m) 
+		bool HasPerVertexQuality (const TriMesh < vertex::vector_ocf< VertexType > , FaceContainerType > & m)
 	{
-	  if(VertexType::HasQualityOcf()) return m.vert.IsQualityEnabled();
-	  else return VertexType::HasQuality();
+		if(VertexType::HasQualityOcf()) return m.vert.IsQualityEnabled();
+		else return VertexType::HasQuality();
 	}
 
 	template < class VertexType >
diff --git a/wrap/io_trimesh/io_mask.h b/wrap/io_trimesh/io_mask.h
index a7351012..af997447 100644
--- a/wrap/io_trimesh/io_mask.h
+++ b/wrap/io_trimesh/io_mask.h
@@ -46,14 +46,12 @@ Initial commit
 #ifndef __VCGLIB_IOTRIMESH_IO_MASK
 #define __VCGLIB_IOTRIMESH_IO_MASK
 
-//#include<wrap/callback.h>
-
 namespace vcg {
 namespace tri {
 namespace io {
 
 /**
-@name Load and Save in Ply format
+@name Input/output data mask
 */
 //@{
   
@@ -66,30 +64,32 @@ public:
 */
 
 enum {
-	IOM_NONE         = 0x0000,
+	IOM_NONE         = 0x00000,
 
-  IOM_VERTCOORD    = 0x0001,
-	IOM_VERTFLAGS    = 0x0002, 
-	IOM_VERTCOLOR    = 0x0004,
-	IOM_VERTQUALITY  = 0x0008,
-	IOM_VERTNORMAL   = 0x0010,
-	IOM_VERTTEXCOORD = 0x0020,
+  IOM_VERTCOORD    = 0x00001,
+	IOM_VERTFLAGS    = 0x00002,
+	IOM_VERTCOLOR    = 0x00004,
+	IOM_VERTQUALITY  = 0x00008,
+	IOM_VERTNORMAL   = 0x00010,
+	IOM_VERTTEXCOORD = 0x00020,
+  IOM_VERTRADIUS   = 0x10000,
 
-	IOM_FACEINDEX    = 0x0040,
-	IOM_FACEFLAGS    = 0x0080,
-	IOM_FACECOLOR    = 0x0100,
-	IOM_FACEQUALITY  = 0x0200,
-	IOM_FACENORMAL   = 0x0400,
-	IOM_WEDGCOLOR    = 0x0800,
-	IOM_WEDGTEXCOORD = 0x1000,
-	IOM_WEDGTEXMULTI = 0x2000, // Se ha anche l'indice di texture esplicito
-	IOM_WEDGNORMAL   = 0x4000,
+	IOM_FACEINDEX    = 0x00040,
+	IOM_FACEFLAGS    = 0x00080,
+	IOM_FACECOLOR    = 0x00100,
+	IOM_FACEQUALITY  = 0x00200,
+	IOM_FACENORMAL   = 0x00400,
 
-	IOM_CAMERA       = 0x8000,
+	IOM_WEDGCOLOR    = 0x00800,
+	IOM_WEDGTEXCOORD = 0x01000,
+	IOM_WEDGTEXMULTI = 0x02000, // Se ha anche l'indice di texture esplicito
+	IOM_WEDGNORMAL   = 0x04000,
+
+	IOM_CAMERA       = 0x08000,
 
 	IOM_FLAGS        = IOM_VERTFLAGS + IOM_FACEFLAGS,
 
-	IOM_ALL          = 0xFFFF
+	IOM_ALL          = 0xFFFFF
 };
 //
 //
@@ -117,13 +117,13 @@ enum {
 //
 //	if( mask & IOM_CAMERA ) strcat(str," camera");
 //}
-template <class MeshType> 
+template <class MeshType>
 static void ClampMask(MeshType &m, int &mask)
 {
-  if( (mask & IOM_FACECOLOR)    && !HasPerFaceColor(m) ) mask = mask & (~IOM_FACECOLOR);
-  if( (mask & IOM_WEDGTEXCOORD) && !HasPerWedgeTexCoord(m) ) mask = mask & (~IOM_WEDGTEXCOORD);
-  if( (mask & IOM_WEDGNORMAL) && !m.HasPerWedgeNormal() ) mask = mask & (~IOM_WEDGNORMAL);
-  if( (mask & IOM_VERTCOLOR) && !m.HasPerVertexColor() ) mask = mask & (~IOM_VERTCOLOR);
+  if( (mask & IOM_FACECOLOR)    && !HasPerFaceColor(m) )      mask = mask & (~IOM_FACECOLOR);
+  if( (mask & IOM_WEDGTEXCOORD) && !HasPerWedgeTexCoord(m) )  mask = mask & (~IOM_WEDGTEXCOORD);
+  if( (mask & IOM_WEDGNORMAL)   && !m.HasPerWedgeNormal() )   mask = mask & (~IOM_WEDGNORMAL);
+  if( (mask & IOM_VERTCOLOR)    && !m.HasPerVertexColor() )   mask = mask & (~IOM_VERTCOLOR);
 }
 
 }; // end class