[Closed] recreating bad meshes imported from CAD

max probably generates the normal from vertices in the face, and direction is dependent on the order of the verts in the face,

#(1,2,3) vs #(3,2,1)

try…

fn flipface f = ( [f.z,f.y,f.x] )
 theface = for f = 1 to foo.numfaces collect flipface (getFace foo f)

Thank you for your responses claude666 and gazybara!

gazybara, your method is so much faster than what I had hacked together by the wee morning hours! Thank you!

This is what I had. About 500x slower.

function collectFlippedFaces theNode selectIt:true =
(
    local baFlippedFaces = #{}

    if (isKindOf theNode Editable_Poly) do
    (
        local p3ViewDir = -(inverse(getViewTM())).row3
        local iNumFaces = polyOp.getNumFaces theNode

        for iFace = 1 to iNumFaces where ( (dot (polyOp.getFaceNormal theNode iFace) p3ViewDir) > 0 ) do(
            baFlippedFaces[iFace] = true
			
		)
    )

    return baFlippedFaces
)

fn redrawmesh foo=(
local thergb = for x = 1 to 3 collect (random 1 255)
local theface = for f = 1 to foo.numfaces collect getFace foo f
local vertarr = for a = 1 to foo.numverts collect getVert foo a
local themesh = mesh vertices:vertarr faces:theface
local c = convertToPoly(themesh)
local fs = polyop.setFaceSelection c #all
local sm = c.autoSmooth()
local cp = centerpivot c
themesh.wirecolor = color thergb[1] thergb[2] thergb[3]
select themesh
return themesh
)


disablesceneredraw()
thedelarr = #()
flipit = #()
(
		local objs = for obj in selection collect obj
		for obj in objs do
		(
			if (isKindOf obj Editable_Poly) == true then converttomesh obj
			
			--append thedelarr obj
			
			local o = redrawmesh obj
			append thedelarr obj
			local fc = collectFlippedFaces o
			
		if fc.count > 1 then(
			
			if (subObjectLevel != 4) then subObjectLevel = 4

			p = PolyOp.getElementsUsingFace o fc
			polyOp.setFaceSelection o p
			polyop.flipNormals o p
			subObjectLevel=0
			forceCompleteRedraw()
		 )
		 )
		 delete thedelarr
 )
 enablesceneredraw()

You can speed up the code if you use polyOp methods (interface fn) outside the “for-loop”.
Store it (polyOp fn) in variables. Not need to call theses fn’s over and over again. It is slow

getF_Norm = polyOp.getFaceNormal
 setF_Sel = polyop.setFaceSelection 
 -- or i think fester solution is
 c.selectedfaces = #{1..c.numfaces} -- select all faces
 getEleUF = PolyOp.getElementsUsingFace
 flipF = polyop.flipNormals

Denis, here is a small part of a file https://dl.dropbox.com/u/1292183/weird-pipe-max-2013.rar

There are far larger files crammed with lots of “stuff” but this small example illustrates the issue I am having.

Thanks dudes!

I hacked together a script that I use daily for that purpose.
It works great for imported 2d autocad meshes (hatch solids). They always come with randomly flipped normals, so this script aligns every normal to the z axis of the top viewort. It works 100% reliable, as opposed to “unify normals”, which never seems to work.
It needs to run in the top viewport (I guess that could be easily fixed, but it’s all right for my purpose)

Credits for the functions go to:
http://www.illusioncatalyst.com/mxs.php

--unifies all normals for selected meshes in the top viewport

	function getPolyFromMeshFace oPoly iMeshFace =
	(
		if ( (not isValidNode oPoly) or ((classOf oPoly) != Editable_Poly) and ((classOf iMeshFace) != Integer) ) then
		(
			return 0
		)

		if ( (iMeshFace <= 0) or (iMeshFace > (meshOp.getNumFaces oPoly.mesh)) ) then
		(
			return 0
		)

		local baMeshVert = meshOp.getVertsUsingFace oPoly.mesh iMeshFace
		local aiPolyFromVert = #()

		for iVert in baMeshVert do
		(
			append aiPolyFromVert (polyOp.getFacesUsingVert oPoly iVert)
		)
		local baPolyFace = aiPolyFromVert[1] * aiPolyFromVert[2] * aiPolyFromVert[3]

		if (baPolyFace.numberSet == 1) then
		(
			return (baPolyFace as Array)[1]
		)
		else
		(
			local baMeshFaceInPoly = meshOp.getPolysUsingFace oPoly.mesh iMeshFace ignoreVisEdges:false threshhold:179.5
			local baMeshFaceVert = meshOp.getVertsUsingFace oPoly.mesh baMeshFaceInPoly
			local baPolyFaceVert = #{}

			for iFace in baPolyFace do
			(
				baPolyFaceVert = polyOp.getVertsUsingFace oPoly iFace

				if ( ((baPolyFaceVert - baMeshFaceVert).isEmpty == true) and \
					 ((baMeshFaceVert - baPolyFaceVert).isEmpty == true) ) then
				(
					return iFace
				)
			)
		)
	)

	--------------------------------------------------------------------------------

	function posMatch pA pB fT =
	(
		if ((classOf pA == Point3) and (classOf pB == Point3) and (classOf fT == Float)) then
		(
			return (((abs(pA.x - pB.x)) < fT) and ((abs(pA.y - pB.y)) < fT) and ((abs(pA.z - pB.z)) < fT))
		)
		else
		(
			throw "Wrong input in function posMatch()"
		)
	)

	--------------------------------------------------------------------------------

	function getFrontFaces obj steps:0 =
	(
		if ((classOf steps) != Integer) then
		(
			throw "Wrong input in function getFrontFaces(): steps must be a positive Integer"
		)

		local fDotThresh = 1e-3
		local fMatchThresh = 1e-3
		local fOffsetThresh = 1e-2

		local baFrontFaces = #{}
		local iNumFaces = 0

		local p3FaceCenter = [0,0,0]
		local p3FaceNormal = [0,0,0]

		local p3CameraToFaceVect = [0,0,0]
		local fDotViewAngle = 0.0

		local p3CameraPos = (inverse(getViewTM())).row4
		local p3CameraViewDir = -(inverse(getViewTM())).row3
		local bIsPerspective = viewport.isPerspView()

		local fObjMaxDim = distance obj.max obj.min

	-- Editable Poly ---------------------------------------------------------------

		if ((classOf obj) == Editable_Poly) then
		(
			iNumFaces = polyOp.getNumFaces obj

			for i = 1 to iNumFaces do
			(
				p3FaceCenter = polyOp.getFaceCenter obj i
				p3FaceNormal = polyOp.getFaceNormal obj i

				if (bIsPerspective == true) then
				(
					p3CameraToFaceVect = p3FaceCenter - p3CameraPos
					fDotViewAngle = dot p3CameraToFaceVect p3FaceNormal
				)
				else
				(
					fDotViewAngle = dot p3CameraViewDir p3FaceNormal
				)

				if (fDotViewAngle < -fDotThresh) then ( baFrontFaces[i] = true )
			)

	-- set test vert ---------------------------------------------------------------

			local iNumTestVerts = polyOp.getNumVerts obj
			local ap3TestVertPos = for i = 1 to iNumTestVerts collect (polyOp.getVert obj i)

			if (steps > 0) then
			(
				local iNumAllEdges = polyOp.getNumEdges obj
				local aiEdgeVerts = #()

				local ap3NewTestPos = #()
				local p3EdgeVector = [0,0,0]

				for i = 1 to iNumAllEdges do
				(
					aiEdgeVerts = polyOp.getEdgeVerts obj i

					for j = 1 to steps do
					(
						p3EdgeVector = ap3TestVertPos[aiEdgeVerts[2]] - ap3TestVertPos[aiEdgeVerts[1]]
						append ap3NewTestPos (ap3TestVertPos[aiEdgeVerts[1]] + ((p3EdgeVector / (steps +1)) * j) )
					)
				)
				join ap3TestVertPos ap3NewTestPos
				iNumTestVerts = ap3TestVertPos.count
			)

	-- run test --------------------------------------------------------------------

			local ap3CameraToVertDir = #()

			local rTest = ray [0,0,0] [0,0,0]
			local rResult = ray [0,0,0] [0,0,0]
			local aResult = #()
			local p3RayPos = [0,0,0]

			local aIterator = #(true)

			with redraw off
			(
				local oMesh = snapShot obj

	-- ray from vert away from camera ----------------------------------------------

				for i = 1 to iNumTestVerts do
				(
					if (bIsPerspective == true) then
						ap3CameraToVertDir[i] = normalize(ap3TestVertPos[i] - p3CameraPos)
					else
						ap3CameraToVertDir[i] = p3CameraViewDir

					p3RayPos = ap3TestVertPos[i] + ap3CameraToVertDir[i] * fOffsetThresh

					aIterator = #(0)
					for dummy in aIterator do
					(
						rTest = ray p3RayPos ap3CameraToVertDir[i]
						aResult = intersectRayEx oMesh rTest

						if (aResult != undefined) then
						(
							baFrontFaces -= #{getPolyFromMeshFace obj aResult[2]}

							p3RayPos = aResult[1].pos + ap3CameraToVertDir[i] * fOffsetThresh
							append aIterator 0
						)
					)
				)

				baFrontVerts = polyOp.getVertsUsingFace obj baFrontFaces

	-- ray from camera to vert -----------------------------------------------------

				for iVert in baFrontVerts do
				(
					if (bIsPerspective == true) then
					(
						rTest = ray p3CameraPos ap3CameraToVertDir[iVert]
					)
					else
					(
						p3RayPos = ap3TestVertPos[iVert] - p3CameraViewDir * fObjMaxDim
						rTest = ray p3RayPos p3CameraViewDir
					)

					aResult = intersectRayEx oMesh rTest

					if (aResult != undefined) then
					(
						if ((posMatch ap3TestVertPos[iVert] aResult[1].pos fMatchThresh) == false) then
						(
							if (distance p3CameraPos aResult[1].pos) < (distance p3CameraPos ap3TestVertPos[iVert]) then
							(
								baFrontFaces -= polyOp.getFacesUsingVert obj iVert
							)
						)
					)
				)

				baFrontVerts = polyOp.getVertsUsingFace obj baFrontFaces

	-- ray from vert to camera -----------------------------------------------------

				for iVert in baFrontVerts do
				(
					if (bIsPerspective == true) then
					(
						p3RayPos = ap3TestVertPos[iVert] - ap3CameraToVertDir[iVert] * fOffsetThresh
						rTest = ray p3RayPos -ap3CameraToVertDir[iVert]
					)
					else
					(
						p3RayPos = ap3TestVertPos[iVert] - p3CameraViewDir * fOffsetThresh
						rTest = ray p3RayPos -p3CameraViewDir
					)

					rResult = intersectRay obj rTest
					if (rResult != undefined) then
					(
						baFrontFaces -= polyOp.getFacesUsingVert obj iVert
					)
				)

				delete oMesh
			)
			polyOp.setFaceSelection obj baFrontFaces -- just for visual feedback, remove if not needed
		)

	-- Editable Mesh ---------------------------------------------------------------

		else if ((classOf obj) == Editable_Mesh) then
		(
			iNumFaces = meshOp.getNumFaces obj

			for i = 1 to iNumFaces do
			(
				p3FaceCenter = meshOp.getFaceCenter obj i
				p3FaceNormal = getFaceNormal obj i

				if (bIsPerspective == true) then
				(
					p3CameraToFaceVect = p3FaceCenter - p3CameraPos
					fDotViewAngle = dot p3CameraToFaceVect p3FaceNormal
				)
				else
				(
					fDotViewAngle = dot p3CameraViewDir p3FaceNormal
				)

				if (fDotViewAngle < -fDotThresh) then ( baFrontFaces[i] = true )
			)

	-- set test vert ---------------------------------------------------------------

			local iNumTestVerts = meshOp.getNumVerts obj
			local ap3TestVertPos = for i = 1 to iNumTestVerts collect (meshOp.getVert obj i)

			if (steps > 0) then
			(
				with redraw off
				(
					local oPoly = snapShot obj
					local iNumAllFaces = meshOp.getNumFaces oPoly

					for i = 1 to iNumAllFaces do
						for j = 1 to 3 do
							setEdgeVis oPoly i j true

					oPoly = convertToPoly oPoly

					local iNumAllEdges = polyOp.getNumEdges oPoly
					local aiEdgeVerts = #()

					local ap3NewTestPos = #()
					local p3EdgeVector = [0,0,0]

					for i = 1 to iNumAllEdges do
					(
						aiEdgeVerts = polyOp.getEdgeVerts oPoly i

						for j = 1 to steps do
						(
							p3EdgeVector = ap3TestVertPos[aiEdgeVerts[2]] - ap3TestVertPos[aiEdgeVerts[1]]
							append ap3NewTestPos (ap3TestVertPos[aiEdgeVerts[1]] + ((p3EdgeVector / (steps +1)) * j) )
						)
					)
					join ap3TestVertPos ap3NewTestPos
					iNumTestVerts = ap3TestVertPos.count

					delete oPoly
				)
			)

	-- run test --------------------------------------------------------------------

			local ap3CameraToVertDir = #()

			local rTest = ray [0,0,0] [0,0,0]
			local rResult = ray [0,0,0] [0,0,0]
			local aResult = #()
			local p3RayPos = [0,0,0]

			local aIterator = #(true)

	-- ray from vert away from camera ----------------------------------------------

			for i = 1 to iNumTestVerts do
			(
				if (bIsPerspective == true) then
					ap3CameraToVertDir[i] = normalize(ap3TestVertPos[i] - p3CameraPos)
				else
					ap3CameraToVertDir[i] = p3CameraViewDir

				p3RayPos = ap3TestVertPos[i] + ap3CameraToVertDir[i] * fOffsetThresh

				aIterator = #(0)
				for dummy in aIterator do
				(
					rTest = ray p3RayPos ap3CameraToVertDir[i]
					aResult = intersectRayEx obj rTest

					if (aResult != undefined) then
					(
						baFrontFaces[aResult[2]] = false

						p3RayPos = aResult[1].pos + ap3CameraToVertDir[i] * fOffsetThresh
						append aIterator 0
					)
				)
			)

			baFrontVerts = meshOp.getVertsUsingFace obj baFrontFaces

	-- ray from camera to vert -----------------------------------------------------

			for iVert in baFrontVerts do
			(
				if (bIsPerspective == true) then
				(
					rTest = ray p3CameraPos ap3CameraToVertDir[iVert]
				)
				else
				(
					p3RayPos = ap3TestVertPos[iVert] - p3CameraViewDir * fObjMaxDim
					rTest = ray p3RayPos p3CameraViewDir
				)

				aResult = intersectRayEx obj rTest

				if (aResult != undefined) then
				(
					if ((posMatch ap3TestVertPos[iVert] aResult[1].pos fMatchThresh) == false) then
					(
						if (distance p3CameraPos aResult[1].pos) < (distance p3CameraPos ap3TestVertPos[iVert]) then
						(
							baFrontFaces -= meshOp.getFacesUsingVert obj iVert
						)
					)
				)
			)

			baFrontVerts = meshOp.getVertsUsingFace obj baFrontFaces

	-- ray from vert to camera -----------------------------------------------------

			for iVert in baFrontVerts do
			(
				if (bIsPerspective == true) then
				(
					p3RayPos = ap3TestVertPos[iVert] - ap3CameraToVertDir[iVert] * fOffsetThresh
					rTest = ray p3RayPos -ap3CameraToVertDir[iVert]
				)
				else
				(
					p3RayPos = ap3TestVertPos[iVert] - p3CameraViewDir * fOffsetThresh
					rTest = ray p3RayPos -p3CameraViewDir
				)

				rResult = intersectRay obj rTest

				if (rResult != undefined) then
				(
					baFrontFaces -= meshOp.getFacesUsingVert obj iVert
				)
			)
			setFaceSelection obj baFrontFaces -- just for visual feedback, remove if not needed
		)

	-- Neither Editable Poly, nor Editable Mesh ------------------------------------

		else
		(
			throw "Wrong input in function getFrontFaces()"
		)

		return baFrontFaces
	)



	currentView=viewport.getType()

	
	if (currentView == #view_top) then
	(
		undo "fix normals" on
		(
			
			local obj_count=0
			local frontFaces_count=0
			local totalFaces_count=0
			
			local totalNodesProcessed=selection.count
			
			--disableSceneRedraw()
			progressStart "fixing faces..."

			local percent_count=1
			--unify faces to current view
			
			for obj in selection where (classOf obj==Editable_Mesh) do
			(
					obj_count += 1
					frontFaces = getFrontFaces obj
					frontFaces_count += frontFaces.numberSet
					totalFaces_count += obj.numfaces
					meshop.flipNormals obj frontFaces
					meshop.flipNormals obj #{1..obj.numfaces}
					setFaceSelection obj #{}
					update obj
					progressUpdate ((obj_count as float) / totalNodesProcessed * 100)
			)

			progressEnd()
			--enableSceneRedraw()
		
		local flippedFaces_count = (totalFaces_count - frontFaces_count)
		messageBox ((obj_count as string) + " mesh objects processed.
" + (totalFaces_count as string) + " faces.
" + (flippedFaces_count as string) + " faces fixed.") title:"Info" 		)
	)
	else messageBox "Can only operate in Top viewport, since the normals get aligned to the current view. Please chance active viewport and try again." title:"Error"
	

i can’t load this file. it was save in 2013. i have the 2012 highest. please save it as 2010 or 2012

Here is max2010 x64 version

these meshes are all broken. probably it’s a result of bad import. how do you import these meshes?

Yep. I use arc’s in CAD and modify them over the splines. And when i have to use spline in some extreme cases then i drop them in separate layer and in max i need to use this fn every
time which is boring.
But in most cases i recive CAD files from other people and ther is a mess

fn reduceSplinePoints spl knots: collapseSpl:on =
 (
 	local splLength = curvelength spl
 	addModifier spl (Normalize_Spl length:(splLength/dots))
 	if collapseSpl do convertToSplineShape spl
 )
 

plastic,
in your case everything is easy to fix:

 fn flipAllFacesNonUp node = if iskindof node Editable_Mesh do
 (
 	up = [0,0,1]
 	ff = #{}
 	for f=1 to node.numfaces where (dot up (getfacenormal node f)) < 0 do append ff f
 	node.selectedfaces = ff
 	meshop.flipnormals node ff  
 	update node
 )
 /*
 flipAllFacesNonUp $'Color:008'
 */
 

to select faces is not necessary. i do it just to show which were flipped by the function.

but it’s not a good import either.