1.3.2 空间定位-点、向量与参考平面

  """
将输入端 x 输入的列表，根据输入端 Max 和 Min 的取值，映射到[0,1]区间（标准化）
Inputs:
    x: list[float]
        用于标准化的数据列表
    Max: float
        控制最大取值，大于该值的 x 均映射为1
    Min: float
        控制最小取值，小于该值的 x 首先均映射为0
    noZeroB: bool
        是否将映射值为0的值，赋予输入值 noZeroV
    noZeroV: float
        如果 noXeroB 为 True，则用该值替换值为0的x的映射
Output:    
    A：list[float]
        标准化 x 后的值列表
"""
import rhinoscriptsyntax as rs

def Normalization_0to1(x,Max,Min,noZeroB,noZeroV):
    '''
    输入参数（Parameters/Inputs）和返回值（Returns/Outputs）同组件注释
    '''
    if x > Min:
      if x < Max:
        b = x / Max
      else:
        b = 1
    else:
      b = 0
    if noZeroB:
      if b == 0:
        A = noZeroV
      else:
        A = b
    else:
      A = b
      
    return A

A=Normalization_0to1(x,Max,Min,noZeroB,noZeroV)
  

  """
用输入端 minV，截断输入端 x 数值列表，将小于 minV 的值初步均映射为 minV
Inputs:
    x: list[float]
        用于截断的数值列表
    minV: float
        截断值
    noZeroB：bool
        是否将截断后值为0的 x(b) 值赋予值为输入端 noZeroV的值
    noZeroV：float
        替换截断后值为0的 x(b) 的值
Output:
    a: The a output variable
"""
import rhinoscriptsyntax as rs

def Minimum_limit(x,minV,noZeroB,noZeroV):
    '''
    输入参数（Parameters/Inputs）和返回值（Returns/Outputs）同组件注释
    '''
    if x < minV:
      b = minV
    else:
      b = x
    if noZeroB:
      if b == 0:
        A = noZeroV
      else:
        A = b
    else:
      A = b
    return A
    
A=Minimum_limit(x,minV,noZeroB,noZeroV)
  

  """
    自定义计数器，类似 GH 中的 Trigger
    Inputs:
        Run: bool
            是否开始计数
        Reset: bool
            重新计数
        Step: float
            步幅值
        Target: float
            目标结束值
        Interval: int(System.Int32)
            解决方案完成和计划解决方案开始之间的延迟（以毫秒 ms 为单位）。如果延迟为 1ms 或更多，则将使用计时器在将来某个时候触发新的解决方案。如果使用 0ms 的延迟，则下一个解决方案将在当前解决方案中递归运行，这可能会可导致 Rhino 进程耗尽堆栈空间，尽量避免配置为 0ms
            ref:https://mcneel.github.io/grasshopper-api-docs/api/grasshopper/html/M_Grasshopper_Kernel_GH_Document_ScheduleSolution_1.htm
        
    Output:
        Counter: dict(collections.Counter)
            以字典形式返回计数结果
"""

import Grasshopper as gh

def updateComponent(interval):   
    
    def callBack(e):
        ghenv.Component.ExpireSolution(False)
        
    ghenv.Component.OnPingDocument().ScheduleSolution(interval,
        gh.Kernel.GH_Document.GH_ScheduleDelegate(callBack))

# 重置计时器变量 count（Instantiate or reset persistent counter variable）
if "count" not in globals() or Reset:
    count = 0

# 更新变量和组件（Update the variable and component）
if Run and not Reset and count < Target:
    count +=Step
    updateComponent(Interval)

# 输出计数（Output counter）
Counter = count
  

  """
    计算可迭代对象（list）中元素的出现次数。（未将 Python 中的 dict 类型数据转化为 GH 的 tree 型数据输出）
    Inputs:
        List: list[ghdoc Object]
            用于计算频数的输入列表
    Output:
        Counter: dict(collections.Counter)
            以字典形式返回计数结果
"""

import collections
Counter = str(collections.Counter(List))
  

  """
    正弦函数
    Inputs:
        Values: list[float]
            输入值列表
        Sin_period: float
            函数周期 
        Sin_shift: float
            函数偏移
        Sin_amplitude: float
            函数振幅
    Output:
        Sin_y: float
            正弦函数变换后的值
"""

import math

def sin_y():    
    Sin_y=[]
    for v in Values:    
        if Sin_amplitude:
            Sin_y.append(Sin_amplitude*math.sin((1/Sin_period)*v+math.pi/2+Sin_shift))
        else:
            Sin_y.append(math.sin((1/Sin_period)*v+math.pi/2+Sin_shift))
    return Sin_y

if __name__=="__main__":
    Sin_y=sin_y()
  

  """
    用蚁群算法（AntClony Optimization，ACO）求解旅行商（Traveling Salesman Problem，TSP）问题，即对输入的 Cities 点列表排序。（假设有一个旅行商人要拜访 N 个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。TSP 问题是一个 NPC 问题）
    Inputs:
        Cities: list[ghdoc Object]
            代表城市的多个点列表
        antCount: int
            蚁群数量
        nMax: int
            最大迭代次数
        run: bool
            运行组件
    Output:
        Route: list(point)
            排序后的点列表
"""

import rhinoscriptsyntax as rs
import os
import sys
import random
import string
from string import *
from math import *
BestTour = []
CitySet = set()
CityList = []
PheromoneTrailList = []
PheromoneDeltaTrailList = []
CityDistanceList = []
AntList = []
BTC = []


class BACA:
    def __init__(self, cityCount=14, antCount=10, q=80,
                 alpha=2, beta=5, rou=0.3, nMax=10):
        self.CityCount = cityCount
        self.AntCount = antCount
        self.Q = q
        self.Alpha = alpha
        self.Beta = beta
        self.Rou = rou
        self.Nmax = nMax
        self.Shortest = 10e6
        random.seed()
        for nCity in range(self.CityCount):
            BestTour.append(0)
        for row in range(self.CityCount):
            pheromoneList = []
            pheromoneDeltaList = []
            for col in range(self.CityCount):
                pheromoneList.append(100)
                pheromoneDeltaList.append(0)
            PheromoneTrailList.append(pheromoneList)
            PheromoneDeltaTrailList.append(pheromoneDeltaList)

    def ReadCityInfo(self, fileName):
        for i in fileName.keys():
            cityN, cityX, cityY = i, fileName[i][1], fileName[i][2]
            CitySet.add(int(cityN))
            CityList.append((int(cityN), float(cityX), float(cityY)))
        for row in range(self.CityCount):
            distanceList = []
            for col in range(self.CityCount):
                distance = sqrt(pow(
                    CityList[row][1]-CityList[col][1], 2)+pow(CityList[row][2]-CityList[col][2], 2))
                distanceList.append(distance)
            CityDistanceList.append(distanceList)

    def PutAnts(self):
        for antNum in range(self.AntCount):
            city = random.randint(1, self.CityCount)
            ant = ANT(city)
            AntList.append(ant)

    def Search(self):
        for iter in range(self.Nmax):
            self.PutAnts()
            for ant in AntList:
                for ttt in range(len(CityList)):
                    ant.MoveToNextCity(self.Alpha, self.Beta)
                ant.UpdatePathLen()
            tmpLen = AntList[0].CurrLen
            tmpTour = AntList[0].TabuCityList
            for ant in AntList[1:]:
                if ant.CurrLen < tmpLen:
                    tmpLen = ant.CurrLen
                    tmpTour = ant.TabuCityList
            if tmpLen < self.Shortest:
                self.Shortest = tmpLen
                BestTour = tmpTour
            print(iter, ":", self.Shortest, ":", BestTour)
            BTC.append(BestTour)
            self.UpdatePheromoneTrail()

    def UpdatePheromoneTrail(self):
        for ant in AntList:
            for city in ant.TabuCityList[0:-1]:
                idx = ant.TabuCityList.index(city)
                nextCity = ant.TabuCityList[idx+1]
                PheromoneDeltaTrailList[city -
                                        1][nextCity-1] = self.Q/ant.CurrLen
                PheromoneDeltaTrailList[nextCity -
                                        1][city-1] = self.Q/ant.CurrLen
            lastCity = ant.TabuCityList[-1]
            firstCity = ant.TabuCityList[0]
            PheromoneDeltaTrailList[lastCity -
                                    1][firstCity-1] = self.Q/ant.CurrLen
            PheromoneDeltaTrailList[firstCity -
                                    1][lastCity-1] = self.Q/ant.CurrLen
        for (city1, city1X, city1Y) in CityList:
            for (city2, city2X, city2Y) in CityList:
                PheromoneTrailList[city1-1][city2-1] = ((1-self.Rou)*PheromoneTrailList[city1-1][city2-1] +
                                                        PheromoneDeltaTrailList[city1-1][city2-1])
                PheromoneDeltaTrailList[city1-1][city2-1] = 0


class ANT:
    def __init__(self, currCity=0):
        self.TabuCitySet = set()
        self.TabuCityList = []
        self.AllowedCitySet = set()
        self.TransferProbabilityList = []
        self.CurrCity = 0
        self.CurrLen = 0.0
        self.AddCity(currCity)
        pass

    def SelectNextCity(self, alpha, beta):
        if len(self.AllowedCitySet) == 0:
            return (0)
        sumProbability = 0.0
        for city in self.AllowedCitySet:
            sumProbability = sumProbability + (pow(PheromoneTrailList[self.CurrCity-1][city-1], alpha) * pow(
                1.0/CityDistanceList[self.CurrCity-1][city-1], beta))
        self.TransferProbabilityList = []
        for city in self.AllowedCitySet:
            transferProbability = (pow(PheromoneTrailList[self.CurrCity-1][city-1], alpha) * pow(
                1.0/CityDistanceList[self.CurrCity-1][city-1], beta))/sumProbability
            self.TransferProbabilityList.append((city, transferProbability))
        select = 0.0
        for city, cityProb in self.TransferProbabilityList:
            if cityProb > select:
                select = cityProb
        threshold = select * random.random()
        for (cityNum, cityProb) in self.TransferProbabilityList:
            if cityProb >= threshold:
                return (cityNum)
        return (0)

    def MoveToNextCity(self, alpha, beta):
        nextCity = self.SelectNextCity(alpha, beta)
        if nextCity > 0:
            self.AddCity(nextCity)

    def ClearTabu(self):
        self.TabuCityList = []
        self.TabuCitySet.clear()
        self.AllowedCitySet = CitySet - self.TabuCitySet

    def UpdatePathLen(self):
        for city in self.TabuCityList[0:-1]:
            nextCity = self.TabuCityList[self.TabuCityList.index(city)+1]
            self.CurrLen = self.CurrLen + CityDistanceList[city-1][nextCity-1]
        lastCity = self.TabuCityList[-1]
        firstCity = self.TabuCityList[0]
        self.CurrLen = self.CurrLen + CityDistanceList[lastCity-1][firstCity-1]

    def AddCity(self, city):
        if city <= 0:
            return
        self.CurrCity = city
        self.TabuCityList.append(city)
        self.TabuCitySet.add(city)
        self.AllowedCitySet = CitySet - self.TabuCitySet


if __name__ == "__main__":
    citydic = {}
    for i in range(len(Cities)):
        citydic[i+1] = [i+1,
                        rs.PointCoordinates(Cities[i])[0], rs.PointCoordinates(Cities[i])[1]]
    cCount = len(Cities)
    antCount = int(antCount)
    nMax = int(nMax)
    if run == True:
        theant = BACA(cityCount=cCount, antCount=antCount,
                    q=80, alpha=2, beta=5, rou=0.3, nMax=nMax)
        theant.ReadCityInfo(citydic)
        theant.Search()
        BTCO = BTC[-1]
        closep = BTCO[:]
        closep.append(BTCO[0])
        Route = [Cities[i-1] for i in closep]