利用shell删除labelme打错的标签

近一万张标签，组长嫌弃打的太抖了，于是辛苦我一人，造福所有队员——写一个脚本把特定名字的标签框删除，就是苦了我的头发qaq

---

首先，经过探讨之后发现，如果要删除标签框，只需要删除对应json文件中对应的shapes，
所以具体要求如下：
1.需要删除lable名为Red1-8和Blue1-8的shapes内容
2.保留其他标签框：Dark和Red0和Blue0

第一版

#!/bin/bash
cd /home/computer/下载/label-json
	
#这里是放着错误lable的json文件的地方，可以根据自己的情况改变
#FIND_STR="Blue1"

	a=5341
	while [ $a -lt 17121 ]	
	do
		if [ -f $a.json ] 
		then 
			#删除Red1
			while [ `grep -c \"Red1\" $a.json` -ne '0' ];
			do		
				m=$(sed -n '/"Red1"/=' $a.json | head -1)
				if [ $m -ne '6' ]
				then 	
					top=`expr $m - 2`
					buttom=`expr $m + 21`
					sed -i "$top,$buttom d" $a.json
					echo "delete Red1 in $a"
				else
					sed -i "5,28d" $a.json
					echo "delete Red1 in $a"
				fi
			done
			fi		
		((a=a+1))
	done

json文件内容

第一次取的样本较少，看到的json文件大概是是以上模样，于是开始删除的时候只考虑到两种情况：

• 1.删除的标签框是第一个标签框：删除第6-28行
• 2.删除的标签框不是第一个标签框：删除lable向上2行和向下21行

但是问题很快就产生了

因为发现大家打的标签的版本不同，于是导致lable的位置和要删除的行数不同
如下：

第二版

无奈之下只好写第二版，组长给另一个方法：利用大括号匹配来删除，但是可惜的是我的栈实在学的不咋样，于是只好采用更复杂的代码

删除单个标签

#!/bin/bash
cd /home/computer/下载/label-json
#这里是放着错误lable的json文件的地方，可以根据自己的情况改变


#大家打的标签
#1/3508 : 5.0.1 ----Red0/Blue5
#5008 - 5340 : 3.16.7-----Blue2/..
#11008 - 12007 : 4.5.9------Blue5/..
#14008 - 15007 : 4.5.12-----../Blue0/Red0
#16008 - 16536: 3.16.2 buttom-----Blue3/..
#16537 - 17121 :3.16.2 top-------../Blue6
#1-17121其余是：5.0.2


#我写的垃圾代码
	a=1			#第一张标签叫：1.json
	while [ $a -lt 17122 ]			#最后一张标签叫：17121.json
	do
		if [ -f $a.json ] 		#判断是否存在这张标签
		then 
		#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue1\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue1"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue1 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue1 in $a"
				fi
			done
		fi		
		((a=a+1))
	done
	

这样是匹配括号，就可以避免删错了行的问题，具体运行以下：

第三版

第二版可行，于是整合开始第三版，最终定稿

#!/bin/bash
cd /home/computer/下载/label-json
#这里是放着错误lable的json文件的地方，可以根据自己的情况改变


#大家打的标签
#1/3508 : 5.0.1 ----Red0/Blue5
#5008 - 5340 : 3.16.7-----Blue2/..
#11008 - 12007 : 4.5.9------Blue5/..
#14008 - 15007 : 4.5.12-----../Blue0/Red0
#16008 - 16536: 3.16.2 buttom-----Blue3/..
#16537 - 17121 :3.16.2 top-------../Blue6
#1-17121其余是：5.0.2


#我写的垃圾代码
	a=1			#第一张标签叫：1.json
	while [ $a -lt 17122 ]			#最后一张标签叫：17121.json
	do
		if [ -f $a.json ] 		#判断是否存在这张标签
		then 
		#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue1\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue1"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue1 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue1 in $a"
				fi
			done
#------------------Blue2------------------------------------------------			
		#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue2\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue2"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue2 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue2 in $a"
				fi
			done
#---------Blue3--------------------------------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue3\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue3"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue3 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue3 in $a"
				fi
			done
		
#----------------Blue4-------------------------------------------------------------	
		#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue4\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue4"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue4 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue4 in $a"
				fi
			done
#-------------------Blue5----------------------------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue5\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue5"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue5 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue5 in $a"
				fi
			done
#------------------Blue6----------------------------------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue6\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue6"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue6 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue6 in $a"
				fi
			done
#--------------------------Blue7------------------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue7\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue7"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue7 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue7 in $a"
				fi
			done
#----------------------------Blue8-----------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Blue8\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Blue8"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue8 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Blue8 in $a"
				fi
			done
#--------------------------Red1------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red1\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red1"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red1 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red1 in $a"
				fi
			done
#--------------------------Red2------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red2\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red2"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red2 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red2 in $a"
				fi
			done
#--------------------------Red3------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red3\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red3"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red3 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red3 in $a"
				fi
			done
#--------------------------Red4------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red4\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red4"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red4 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red4 in $a"
				fi
			done
#--------------------------Red5------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red5\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red5"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red5 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red5 in $a"
				fi
			done
#--------------------------Red6------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red6\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red6"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red6 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red6 in $a"
				fi
			done
#--------------------------Red7------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red7\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red7"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red7 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red7 in $a"
				fi
			done
#--------------------------Red8------------------------------		
	#while循环，保证每一张标签里面的不需要的标签框都可以删完再转到下一个标签去删标签框
			while [ `grep -c \Red8\" $a.json` -ne '0' ] 
			#判断这张标签里是否在"Red1-8"或者"Blue1-8"这个字符
			do		
				mid=$(sed -n '/"Red8"/=' $a.json | head -1)
				#获得第一次出现这个字符的位置
				lable_top=$mid
				top=$(sed -n "$mid p" $a.json | grep "{" )
				
				lable_flag1=0
				#{存在的标识
				while [ $lable_flag1 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符前面出现的第一个未被匹配的{的行数
					lable_top=`expr $lable_top - 1`
					top=$(sed -n "$lable_top p" $a.json | grep "{" )
					top_buttom=$(sed -n "$lable_top p" $a.json | grep "}" )
					if [ -n "$top" ]
					then
						lable_flag1=`expr $lable_flag1 + 1`
						echo "have { in $lable_top"
					fi
					if [ -n "$top_buttom" ]
					then
						lable_flag1=`expr $lable_flag1 - 1`
						echo "have } in $lable_top"
					fi
						
					if [ $lable_flag1 -eq '1' ]
					then
						echo "The top is $lable_top"
					fi
				done
								
				lable_buttom=$mid
				buttom=$(sed -n "$mid p" $a.json | grep "}" )
				
				lable_flag2=0
				#}存在的标识
				while [ $lable_flag2 -ne '1' ];	#判断标识是否为1
				do
					#以下是获取这个字符后面出现的第一个未被匹配的}的行数
					lable_buttom=`expr $lable_buttom + 1`
					buttom=$(sed -n "$lable_buttom p" $a.json | grep "}" )
					buttom_top=$(sed -n "$lable_buttom p" $a.json | grep "{" )
					if [ -n "$buttom" ]
					then
						lable_flag2=`expr $lable_flag2 + 1`
						echo "have } in $lable_buttom"
					fi
					if [ -n "$buttom_top" ]
					then
						lable_flag2=`expr $lable_flag2 - 1`
						echo "have { in $lable_buttom"
					fi
						
					if [ $lable_flag2 -eq '1' ]
					then
						echo "The buttom is $lable_buttom"
					fi
				done
				#分析：
				#当这个标签框前面有一个不需要删除的标签时，删除的位置向上移动一行
				#当这个标签就是第一个标签框时，只需要删除匹配好的{}位置
				lable_top=`expr $lable_top - 1`
				flag=$(sed -n "$lable_top p" $a.json | grep "}" )
				if [ -n "$flag" ]
				then
					lable_buttom=`expr $lable_buttom - 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red8 in $a"
				else
					lable_top=`expr $lable_top + 1`
					sed -i "$lable_top,$lable_buttom d" $a.json
					echo "delete Red8 in $a"
				fi
			done
	 
	 
		fi		
		((a=a+1))
	done
	

这是我写shell以来写的最麻烦的脚本啦，原理不复杂，就是有点烦，在这里感谢组长 ，没有他也就没有这个脚本。