Clamps RGBA vertex map values to the 0-1 range. Stick this into a folder called "lxserv" in your user scripts directory. Restart MODO. Use "ffr.clampRGBA" to run the command.

clampRGBA.py

#!/usr/bin/env python

import lx
import lxifc
import lxu.command

def vclamp (a):
	b = list(a)
	beenClamped = False
	for x in xrange(4):
		if b[x] < 0.0:
			b[x] = 0.0
			beenClamped = True
		elif b[x] > 1.0:
			b[x] = 1.0
			beenClamped = True
	return beenClamped, tuple(b)

class ListMaps (lxifc.Visitor):
	def __init__ (self, meshmap):
		self.meshmap = meshmap
		self.mapIDs = []

	def vis_Evaluate (self):
		self.mapIDs.append (self.meshmap.ID ())

class ClampValues (lxifc.Visitor):
	def __init__ (self, point, polygon, meshMapIDs, mode):
		self.point = point
		self.polygon = polygon
		self.meshMapIDs = meshMapIDs
		self.mode = mode

		self.value = lx.object.storage ('f', 4)
		self.value.set ((0.0,0.0,0.0,1.0))

	def vis_Evaluate (self):
		pointID = self.point.ID ()
		polygonCount = self.point.PolygonCount ()
		polygonIDs = []
		
		for x in xrange(polygonCount):
			polygonIDs.append (self.point.PolygonByIndex(x))
		
		for meshMapID in self.meshMapIDs:
			self.point.MapEvaluate (meshMapID, self.value)
			continuous_value = self.value.get ()
			
			clamped, clamped_value = vclamp(continuous_value)
			if clamped:
				self.value.set (clamped_value)
				self.point.SetMapValue (meshMapID, self.value)
			
			for polygonID in polygonIDs:
				self.polygon.Select (polygonID)
				if self.polygon.TestMarks (self.mode):
					try:
						self.polygon.MapValue (meshMapID, pointID, self.value)
					except:
						pass
					else:
						disco_value = self.value.get ()
						clamped, clamped_value = vclamp(disco_value)
						if clamped:
							self.value.set (clamped_value)
							self.polygon.SetMapValue (pointID, meshMapID, self.value)

class ClampRGBA_Cmd(lxu.command.BasicCommand):

	def __init__(self):
		lxu.command.BasicCommand.__init__(self)

	def cmd_UserName(self):
 		return 'Clamp RGBA Values'

 	def cmd_Desc(self):
 		return 'Limit RGBA vertex map values to between 0.0 and 1.0'

 	def cmd_Tooltip(self):
 		return 'Limit RGBA vertex map values to between 0.0 and 1.0'

 	def cmd_Help(self):
 		return 'http://www.farfarer.com/'

	def basic_ButtonName(self):
		return 'Clamp RGBA Values'

	def cmd_Flags(self):
		return lx.symbol.fCMD_MODEL | lx.symbol.fCMD_UNDO

	def basic_Enable(self, msg):
		return True

	def cmd_Interact(self):
		pass

	def basic_Execute(self, msg, flags):
			meshMapNames = []
			
			mesh_svc = lx.service.Mesh ()
			mode = mesh_svc.ModeCompose ('select', 'hide lock')
			
			sel_svc = lx.service.Selection ()
			sel_type_vmap = sel_svc.LookupType (lx.symbol.sSELTYP_VERTEXMAP)
			vmap_pkt_trans = lx.object.VMapPacketTranslation (sel_svc.Allocate (lx.symbol.sSELTYP_VERTEXMAP))
			sel_vmap_count = sel_svc.Count (sel_type_vmap)
			for vmap_idx in xrange (sel_vmap_count):
				pkt = sel_svc.ByIndex (sel_type_vmap, vmap_idx)
				vmap_type = vmap_pkt_trans.Type (pkt)
				if vmap_type == lx.symbol.i_VMAP_RGBA:
					meshMapNames.append(vmap_pkt_trans.Name (pkt))
			
			allMaps = False
			if len(meshMapNames) == 0:
				allMaps = True
			
			layer_svc = lx.service.Layer ()
			layer_scan = lx.object.LayerScan (layer_svc.ScanAllocate (lx.symbol.f_LAYERSCAN_EDIT))
			if not layer_scan.test ():
				return

			layer_scan_count = layer_scan.Count ()
			for l in xrange (layer_scan_count):

				mesh_item = layer_scan.MeshItem (l)

				mesh = lx.object.Mesh (layer_scan.MeshEdit (l))
				if not mesh.test ():
					continue

				if mesh.PolygonCount () == 0:
					continue
				
				point = lx.object.Point (mesh.PointAccessor ())
				polygon = lx.object.Polygon (mesh.PolygonAccessor ())
				meshmap = lx.object.MeshMap (mesh.MeshMapAccessor ())
				if not (point.test () and polygon.test () and meshmap.test()):
					continue

				# RGBA MAPS
				meshMapIDs = []
				if not allMaps:
					for meshMapName in meshMapNames:
						try:
							meshmap.SelectByName (lx.symbol.i_VMAP_RGBA, meshMapName)
						except:
							continue
						else:
							meshMapIDs.append (meshmap.ID ())
				else:
					meshmap.FilterByType (lx.symbol.i_VMAP_RGBA)
					mapVisitor = ListMaps (meshmap)
					meshmap.Enumerate (lx.symbol.iMARK_ANY, mapVisitor, 0)
					meshMapIDs = mapVisitor.mapIDs
					meshmap.FilterByType (0)
				
				visitor = ClampValues (point, polygon, meshMapIDs, mode)
				point.Enumerate (mode, visitor, 0)

				layer_scan.SetMeshChange (l, lx.symbol.f_MESHEDIT_MAP_OTHER | lx.symbol.f_MESHEDIT_MAP_CONTINUITY)

			layer_scan.Apply ()

lx.bless (ClampRGBA_Cmd, 'ffr.clampRGBA')