Script-6.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "id": "30dd916b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6d43c72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "#Lab 6- Amarachi Akunna Onyekachi\n",
    "\n",
    "import arcpy\n",
    "\n",
    "\n",
    "class Toolbox(object):\n",
    "    def __init__(self):\n",
    "        \"\"\"Define the toolbox (the name of the toolbox is the name of the\n",
    "        .pyt file).\"\"\"\n",
    "        self.label = \"My First Toolbox\"\n",
    "        self.alias = \"toolbox\"\n",
    "\n",
    "        # List of tool classes associated with this toolbox\n",
    "        self.tools = [lab1_q1,lab1_q3,lab2_q6,lab3_q3,lab5]\n",
    "\n",
    "#Question 1\n",
    "class lab1_q1(object):\n",
    "    def __init__(self):\n",
    "        \"\"\"Define the tool (tool name is the name of the class).\"\"\"\n",
    "        self.label = \"Health Monitor Tool\" #tool name label\n",
    "        self.description = \"Diagnosing if a person is underweight or overweight\"\n",
    "        self.canRunInBackground = False\n",
    "\n",
    "    def getParameterInfo(self): #Defining the parameters (user input) using arcpy.Parameter()\n",
    "        \"\"\"Define parameter definitions\"\"\"\n",
    "        param0 = arcpy.Parameter(displayName = \"Weight in pounds (lbs)\", name = \"wt\", datatype = \"GPString\", parameterType = \"Required\", direction = \"Input\")\n",
    "        param1 = arcpy.Parameter(displayName = \"Height in feet (ft)\", name = \"ft\", datatype = \"GPString\", parameterType = \"Required\", direction = \"Input\")\n",
    "        params = [param0, param1]\n",
    "        return params\n",
    "\n",
    "    def isLicensed(self):\n",
    "        \"\"\"Set whether tool is licensed to execute.\"\"\"\n",
    "        return True\n",
    "\n",
    "    def updateParameters(self, parameters):\n",
    "        \"\"\"Modify the values and properties of parameters before internal\n",
    "        validation is performed.  This method is called whenever a parameter\n",
    "        has been changed.\"\"\"\n",
    "        return\n",
    "\n",
    "    def updateMessages(self, parameters):\n",
    "        \"\"\"Modify the messages created by internal validation for each tool\n",
    "        parameter.  This method is called after internal validation.\"\"\"\n",
    "        return\n",
    "\n",
    "    def execute(self, parameters, messages):\n",
    "        \"\"\"The source code of the tool.\"\"\"\n",
    "        #Used try-except for error handling, if-elif-else statement\n",
    "        try:\n",
    "            #height = float(input('The height of the patient in ft: '))  # in feet\n",
    "            height = float(parameters[1].ValueAsText) #height is the second parameter (index = 1)\n",
    "        except ValueError:\n",
    "            #print('Invalid Input for Height!') #change print to arcpy.addMessage\n",
    "            arcpy.AddMessage('Invalid Input for Height!')\n",
    "\n",
    "        try:\n",
    "            #weight = float(input('The weight of the patient in lbs: '))  # in pounds\n",
    "            weight = float(parameters[0].ValueAsText) #weight is the first parameter (index = 0)\n",
    "        except ValueError:\n",
    "            #print('Invalid Input for Weight!')\n",
    "            arcpy.AddMessage('Invalid Input for Weight!')\n",
    "\n",
    "        try:\n",
    "            sw = (height * 30.48-105)/0.454 #The standard weight of the patient\n",
    "        except ValueError:\n",
    "            #print('Invalid Input for Height and/or Weight!')\n",
    "            arcpy.AddMessage('Invalid Input for Height and/or Weight!')\n",
    "        except NameError:\n",
    "            #print('Invalid Input for Height and/or Weight!')\n",
    "            arcpy.AddMessage('Invalid Input for Height and/or Weight!')\n",
    "\n",
    "        try:\n",
    "            if weight < sw*0.9 and weight > 0 and height > 0:\n",
    "                #print('Standard weight =', format(sw, '.2f'), 'This person is underweight!')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This person is underweight!')\n",
    "            elif sw *0.9 <= weight and weight <= sw*1.1 and weight > 0 and height > 0:\n",
    "                #print('Standard weight =', format(sw, '.2f'), 'This person has a normal weight')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This person has a normal weight')\n",
    "            elif sw * 1.1 < weight and weight <= sw*1.2 and weight > 0 and height > 0:\n",
    "                #print('Standard weight =', format(sw, '.2f'), 'This person is overweight!')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This person is overweight!')\n",
    "            elif sw*1.2 < weight and weight <= sw*1.3 and weight > 0 and height > 0:\n",
    "                #print('Standard weight =', format(sw, '.2f'), 'This person has Class I Obesity!')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This person has Class I Obesity!')\n",
    "            elif sw*1.3< weight and weight <= sw*1.4 and weight > 0 and height > 0:\n",
    "                #print('Standard weight =', format(sw, '.2f'), 'This person has Class II Obesity!')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This person has Class II Obesity!')\n",
    "            elif sw*1.4< weight and weight > 0 and height > 0:\n",
    "                #print('Standard weight =', format(sw, '.2f'), 'This person has Class III Obesity!')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This person has Class III Obesity!')\n",
    "            else:\n",
    "                #print('Standard weight =', format(sw, '.2f'), ', which is impossible for a person!')\n",
    "                arcpy.AddMessage('Standard weight = ')\n",
    "                arcpy.AddMessage(format(sw, '.2f'))\n",
    "                arcpy.AddMessage('This is impossible for a person!')\n",
    "        except ValueError:\n",
    "            #print('Unable to calculate Standard Weight!')\n",
    "            arcpy.AddMessage('Unable to calculate Standard Weight!')\n",
    "        except NameError:\n",
    "            #print('Unable to calculate the Standard Weight!')\n",
    "            arcpy.AddMessage('Unable to calculate the Standard Weight!')\n",
    "            \n",
    "        #ValueError: The Python ValueError is raised when the wrong value is assigned to an object.\n",
    "        #This can happen if the value is invalid for a given operation, or if the value does not exist\n",
    "\n",
    "        #NameError:NameError occurs when you try to use a variable, function, or module that doesn't exist\n",
    "        #or wasn't used in a valid way. Some of the common mistakes that cause this error are: Using a variable or function name that is yet to be defined.\n",
    "\n",
    "        # What does a negative standard weight mean?\n",
    "        return\n",
    "\n",
    "    def postExecute(self, parameters):\n",
    "        \"\"\"This method takes place after outputs are processed and\n",
    "        added to the display.\"\"\"\n",
    "        return\n",
    "\n",
    "#Question 2\n",
    "class lab1_q3(object):\n",
    "    def __init__(self):\n",
    "        \"\"\"Define the tool (tool name is the name of the class).\"\"\"\n",
    "        self.label = \"Degree Convertor Tool\" #tool name label\n",
    "        self.description = \"converting dd:mm:ss to decimal degrees\"\n",
    "        self.canRunInBackground = False\n",
    "\n",
    "    def getParameterInfo(self):\n",
    "        \"\"\"Define parameter definitions\"\"\"\n",
    "        param0 = arcpy.Parameter(displayName = \"Degrees\", name = \"dd\", datatype = \"GPLong\", parameterType = \"Required\", direction = \"Input\")\n",
    "        # GPLong accepts interger values\n",
    "        param0.filter.type = \"Range\"\n",
    "        param0.filter.list = [0,180]\n",
    "        param1 = arcpy.Parameter(displayName = \"Minutes\", name = \"mm\", datatype = \"GPLong\", parameterType = \"Required\", direction = \"Input\")\n",
    "        param1.filter.type = \"Range\"\n",
    "        param1.filter.list = [0,60]\n",
    "        param2 = arcpy.Parameter(displayName = \"Seconds\", name = \"ss\", datatype = \"GPLong\", parameterType = \"Required\", direction = \"Input\")\n",
    "        param2.filter.type = \"Range\"\n",
    "        param2.filter.list = [0,60]\n",
    "        params = [param0,param1,param2]\n",
    "        return params\n",
    "\n",
    "    def isLicensed(self):\n",
    "        \"\"\"Set whether tool is licensed to execute.\"\"\"\n",
    "        return True\n",
    "\n",
    "    def updateParameters(self, parameters):\n",
    "        \"\"\"Modify the values and properties of parameters before internal\n",
    "        validation is performed.  This method is called whenever a parameter\n",
    "        has been changed.\"\"\"\n",
    "        return\n",
    "\n",
    "    def updateMessages(self, parameters):\n",
    "        \"\"\"Modify the messages created by internal validation for each tool\n",
    "        parameter.  This method is called after internal validation.\"\"\"\n",
    "        return\n",
    "\n",
    "    def execute(self, parameters, messages):\n",
    "        \"\"\"The source code of the tool.\"\"\"\n",
    "        # Used try-except for error handling\n",
    "        try:\n",
    "            #dms = input('Input your degreee in angular form (dd:mm:ss) to convert it to decimal degrees: ')\n",
    "            value0 = float(parameters[0].ValueAsText)\n",
    "            value1 = float(parameters[1].ValueAsText)\n",
    "            value2 = float(parameters[2].ValueAsText)\n",
    "            #list_dms = dms.split(':')\n",
    "            #decimal_degree = int(list_dms[0]) + (int(list_dms[1]) / 60) + (int(list_dms[2]) / (60 * 60))\n",
    "            decimal_degree = float(value0) + (float(value1) / 60) + (float(value2) / (60 * 60))\n",
    "            #print('The decimal degrees equivalent is', format(decimal_degree, '.2f'), '°')\n",
    "            arcpy.AddMessage('The decimal degrees equivalent = ')\n",
    "            arcpy.AddMessage(\"%.2f\" % decimal_degree) \n",
    "        except ValueError:\n",
    "            #print('Invalid Format! Unable to convert to decimal degrees!')\n",
    "            arcpy.AddMessage('Invalid Format! Unable to convert to decimal degrees!')\n",
    "        return\n",
    "\n",
    "    def postExecute(self, parameters):\n",
    "        \"\"\"This method takes place after outputs are processed and\n",
    "        added to the display.\"\"\"\n",
    "        return\n",
    "\n",
    "\n",
    "#Question 3\n",
    "class lab2_q6(object): \n",
    "    def __init__(self):\n",
    "        \"\"\"Define the tool (tool name is the name of the class).\"\"\"\n",
    "        self.label = \"Best Locator Tool\"\n",
    "        self.description = \"Selecting the best location for a regional human resource department\"\n",
    "        self.canRunInBackground = False\n",
    "\n",
    "    def getParameterInfo(self): #Defining the parameters (user input) using arcpy.Parameter()\n",
    "        \"\"\"Define parameter definitions\"\"\"\n",
    "        param0 = arcpy.Parameter(displayName=\"Pick a city file: \",name=\"city\",datatype = \"DeTextfile\", direction = \"Input\", parameterType = \"Required\")\n",
    "        param1 = arcpy.Parameter(displayName=\"Pick a location file: \",name=\"location\",datatype = \"DeTextfile\", direction = \"Input\", parameterType = \"Required\")                       \n",
    "        params = [param0,param1]\n",
    "        return params\n",
    "\n",
    "    def isLicensed(self):\n",
    "        \"\"\"Set whether tool is licensed to execute.\"\"\"\n",
    "        return True\n",
    "\n",
    "    def updateParameters(self, parameters):\n",
    "        \"\"\"Modify the values and properties of parameters before internal\n",
    "        validation is performed.  This method is called whenever a parameter\n",
    "        has been changed.\"\"\"\n",
    "        return\n",
    "\n",
    "    def updateMessages(self, parameters):\n",
    "        \"\"\"Modify the messages created by internal validation for each tool\n",
    "        parameter.  This method is called after internal validation.\"\"\"\n",
    "        return\n",
    "\n",
    "    def execute(self, parameters, messages):\n",
    "        \"\"\"The source code of the tool.\"\"\"\n",
    "        #city_file = open('cities.txt','r') #opening a text file for the pupose of reading it i.e file 1\n",
    "        city_file = open(parameters[0].valueAsText,\"r\")\n",
    "        #location_file = open('locations.txt','r') #opening a text file for the pupose of reading it i.e file 2\n",
    "        location_file = open(parameters[1].valueAsText,\"r\")\n",
    "        \n",
    "        all_cities = city_file.readlines()[1:] #reading file 1, excluding the header\n",
    "        all_locations = location_file.readlines()[1:] #reading file 2, excluding the first line, which is the header\n",
    "        location_list = [] #creating an empty list\n",
    "\n",
    "        for aloc in all_locations: #reading file 2\n",
    "            alocArgList = aloc.split(',') #spliting the contents of file 2\n",
    "            location_ID =  alocArgList[0] #calling a column \n",
    "            location_x =   float(alocArgList[1]) #calling a column and tranforming its values to float\n",
    "            location_y =   float(alocArgList[2]) #calling a column and tranforming its values to float\n",
    "            \n",
    "            total_distance = 0\n",
    "            for aCity in all_cities: #reading file 1\n",
    "                acityArgList = aCity.split(',') #spliting the contents of file 1\n",
    "                city_name = acityArgList[0] #calling a column \n",
    "                city_x = float(acityArgList[1]) #calling a column and tranforming its values to float\n",
    "                city_y = float(acityArgList[2]) #calling a column and tranforming its values to float\n",
    "                distance_calc = ((city_x-location_x)**2 + (city_y-location_y)**2)**.5 #distance calculation\n",
    "                total_distance += distance_calc #incrementing the distance calculated above into total_distance (was intially set to 0)\n",
    "                total_distance_miles = (total_distance/5280) # Converting feet to miles using 1 mile = 5280 feet\n",
    "            location_list.append((location_ID, total_distance_miles)) #appending two columns into a an empty lise\n",
    "        location_list.sort(key = lambda x:x[1]) #sorting a list\n",
    "        #location_list[0][0]\n",
    "        #print(location_list)\n",
    "        #arcpy.AddMessage(location_list)\n",
    "        #print('Best location ID =' , location_list[0][0],'.','Average Distance (miles) from all cities =', '%.2f'%location_list[0][1] )\n",
    "        arcpy.AddMessage('Best location ID =')\n",
    "        arcpy.AddMessage(location_list[0][0])\n",
    "        arcpy.AddMessage('Average Distance (miles) from all cities =')\n",
    "        arcpy.AddMessage('%.2f'%location_list[0][1])\n",
    "\n",
    "        city_file.close()\n",
    "        location_file.close()\n",
    "        return\n",
    "\n",
    "    def postExecute(self, parameters):\n",
    "        \"\"\"This method takes place after outputs are processed and\n",
    "        added to the display.\"\"\"\n",
    "        return\n",
    "\n",
    "\n",
    "#Question 4\n",
    "class lab3_q3(object):\n",
    "    def __init__(self):\n",
    "        \"\"\"Define the tool (tool name is the name of the class).\"\"\"\n",
    "        self.label = \"Highway Analysis Tool\"\n",
    "        self.description = \"\"\n",
    "        self.canRunInBackground = False\n",
    "\n",
    "    def getParameterInfo(self):\n",
    "        \"\"\"Define parameter definitions\"\"\"\n",
    "        hwyList = [\"I10\",\"I20\",\"I40\",\"I60\",\"I70\",\"I75\",\"I80\",\"I85\",\"I90\",\"I95\"]\n",
    "        param0 = arcpy.Parameter(displayName=\"Pick an Interstate Highway Feature Class\",name=\"intFC\",datatype=\"DEFeatureClass\",parameterType=\"Required\",direction=\"Input\")\n",
    "        param1 = arcpy.Parameter(displayName=\"Pick a City Feature Class\",name=\"cityFC\",datatype=\"DEFeatureClass\",parameterType=\"Required\",direction=\"Input\")\n",
    "        param2 = arcpy.Parameter(displayName=\"Choose the First Highway\",name=\"hwy1\",datatype=\"GPString\",parameterType=\"Required\",direction=\"Input\")\n",
    "        param2.filter.type = \"ValueList\"\n",
    "        param2.filter.list = hwyList\n",
    "        param3 = arcpy.Parameter(displayName=\"Choose the Second Highway\",name=\"hwy2\",datatype=\"GPString\",parameterType=\"Required\",direction=\"Input\")\n",
    "        param3.filter.type = \"ValueList\"\n",
    "        param3.filter.list = hwyList\n",
    "        param4 = arcpy.Parameter(displayName=\"Buffer Distance\",name=\"BuffDist\",datatype=\"GPLinearUnit\",parameterType=\"Required\",direction=\"Input\")\n",
    "        param5 = arcpy.Parameter(displayName=\"Pick a Field to Sum\",name=\"SumFld\",datatype=\"Field\",parameterType=\"Required\",direction=\"Input\")\n",
    "        param5.parameterDependencies = [param1.name]\n",
    "        params = [param0,param1,param2,param3,param4,param5]\n",
    "        return params\n",
    "\n",
    "    def isLicensed(self):\n",
    "        \"\"\"Set whether tool is licensed to execute.\"\"\"\n",
    "        return True\n",
    "\n",
    "    def updateParameters(self, parameters):\n",
    "        \"\"\"Modify the values and properties of parameters before internal\n",
    "        validation is performed.  This method is called whenever a parameter\n",
    "        has been changed.\"\"\"\n",
    "        return\n",
    "\n",
    "    def updateMessages(self, parameters):\n",
    "        \"\"\"Modify the messages created by internal validation for each tool\n",
    "        parameter.  This method is called after internal validation.\"\"\"\n",
    "        return\n",
    "\n",
    "    def execute(self, parameters, messages):\n",
    "        \"\"\"The source code of the tool.\"\"\"\n",
    "        # To allow overwriting outputs change overwriteOutput option to True.\n",
    "        arcpy.env.overwriteOutput = True\n",
    "        arcpy.env.workspace = 'C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_6\\\\'\n",
    "\n",
    "        #Section for configuring input data sources\n",
    "        #CITIES = \"CITIES.shp\"\n",
    "        CITIES = parameters[1].ValueAsText\n",
    "        #intrstat = \"intrstat.shp\"\n",
    "        intrstat = parameters[0].ValueAsText\n",
    "\n",
    "        # Get user's input for two highway choices\n",
    "        #$hwyListStr = input('Please type two highways to analyze- ExL I40 I80\\n')\n",
    "        #hwyList = hwyListStr.split()\n",
    "        #hw1 = hwyList[0]\n",
    "        hwyList = [parameters[2].ValueAsText, parameters[3].ValueAsText]\n",
    "        #bufDistStr = input('Please input the buffer distance values here (in miles): Ex - 30\\n')\n",
    "\n",
    "\n",
    "        for aHwy in hwyList:\n",
    "            # Process: Select (Select) (analysis)\n",
    "            intrstat_Select_2_4 = \"intrstat_Select.shp\"\n",
    "            arcpy.analysis.Select(intrstat, intrstat_Select_2_4, \"ROUTE_NUM = '\"+aHwy+\"'\")\n",
    "\n",
    "            # Process: Buffer (Buffer) (analysis)\n",
    "            intrstat_Buffer_4 = \"intrstat_Buffer_4.shp\"\n",
    "            arcpy.analysis.Buffer(intrstat_Select_2_4, intrstat_Buffer_4, parameters[4].ValueAsText, \"FULL\", \"ROUND\", \"NONE\", [], \"PLANAR\")\n",
    "\n",
    "            # Process: Clip (Clip) (analysis)\n",
    "            CITIES_Clip_4 = \"CITIES_Clip_4.shp\"\n",
    "            arcpy.analysis.Clip(CITIES, intrstat_Buffer_4, CITIES_Clip_4)\n",
    "\n",
    "            # Process: Summary Statistics (Summary Statistics) (analysis)\n",
    "            Sum_table_2_4 = \"Cities\"+aHwy+\"Buffer\"+parameters[4].ValueAsText+\".shp\"\n",
    "            #arcpy.analysis.Statistics(CITIES_Clip_4, Sum_table_2_4, [[\"POP1990\", \"SUM\"], [\"HISPANIC\", \"SUM\"]])\n",
    "            arcpy.analysis.Statistics(CITIES_Clip_4, Sum_table_2_4, [[parameters[5].ValueAsText, \"SUM\"]])\n",
    "        #print(aHwy+ ' just being completed.')\n",
    "        #print(' All Completed')\n",
    "        arcpy.AddMessage('All Completed')\n",
    "        \n",
    "        return\n",
    "\n",
    "    def postExecute(self, parameters):\n",
    "        \"\"\"This method takes place after outputs are processed and\n",
    "        added to the display.\"\"\"\n",
    "        return\n",
    "\n",
    "#Question 5\n",
    "class lab5(object):\n",
    "    def __init__(self):\n",
    "        \"\"\"Define the tool (tool name is the name of the class).\"\"\"\n",
    "        self.label = \"Suitability Analysis Tool\"\n",
    "        self.description = \"\"\n",
    "        self.canRunInBackground = False\n",
    "\n",
    "    def getParameterInfo(self):\n",
    "        \"\"\"Define parameter definitions\"\"\"\n",
    "        param0 = arcpy.Parameter(displayName = \"Slope:\", name = \"slp\", datatype = \"GPDouble\", parameterType = \"Required\", direction = \"Input\")\n",
    "        param0.filter.type = \"Range\"\n",
    "        param0.filter.list = [0, 1]\n",
    "        param1 = arcpy.Parameter(displayName = \"Land Use:\", name = \"landUse\", datatype = \"GPDouble\", parameterType = \"Required\", direction = \"Input\")\n",
    "        param1.filter.type = \"Range\"\n",
    "        param1.filter.list = [0, 1]\n",
    "        param2 = arcpy.Parameter(displayName = \"Distance to streams:\", name = \"dst2strm\", datatype = \"GPDouble\", parameterType = \"Required\", direction = \"Input\")\n",
    "        param2.filter.type = \"Range\"\n",
    "        param2.filter.list = [0, 1]\n",
    "        params = [param0, param1, param2]\n",
    "        return params\n",
    "\n",
    "    def isLicensed(self):\n",
    "        \"\"\"Set whether tool is licensed to execute.\"\"\"\n",
    "        return True\n",
    "\n",
    "    def updateParameters(self, parameters):\n",
    "        \"\"\"Modify the values and properties of parameters before internal\n",
    "        validation is performed.  This method is called whenever a parameter\n",
    "        has been changed.\"\"\"\n",
    "        return\n",
    "\n",
    "    def updateMessages(self, parameters):\n",
    "        \"\"\"Modify the messages created by internal validation for each tool\n",
    "        parameter.  This method is called after internal validation.\"\"\"\n",
    "        return\n",
    "\n",
    "    def execute(self, parameters, messages):\n",
    "        \"\"\"The source code of the tool.\"\"\"\n",
    "        #import arcpy\n",
    "        #from arcpy.sa import *\n",
    "\n",
    "        #workplace location\n",
    "        arcpy.env.workspace = \"C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_5\\\\Data.gdb\\\\\"\n",
    "        arcpy.env.overwriteOutput = True\n",
    "\n",
    "        value0 = float(parameters[0].ValueAsText)\n",
    "        value1 = float(parameters[1].ValueAsText)\n",
    "        value2 = float(parameters[2].ValueAsText)\n",
    "\n",
    "        # Checking out necessary licenses\n",
    "        arcpy.CheckOutExtension(\"3D\")\n",
    "        #arcpy.CheckOutExtension(\"spatial\")\n",
    "        arcpy.CheckOutExtension(\"ImageAnalyst\")\n",
    "\n",
    "        # Setting up Geoprocessing environments\n",
    "        arcpy.env.snapRaster = \"C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_5\\\\Data.gdb\\\\Elevation\"\n",
    "        arcpy.env.extent = \"439952.113762345 200181.284694512 513122.113762345 253671.284694512\"\n",
    "        arcpy.env.cellSize = \"30\"\n",
    "        arcpy.env.mask = \"C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_5\\\\Data.gdb\\\\Elevation\"\n",
    "\n",
    "        Streams = \"C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_5\\\\Data.gdb\\\\Streams\"\n",
    "        Elevation = arcpy.Raster(\"C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_5\\\\Data.gdb\\\\Elevation\")\n",
    "        LandUse = arcpy.Raster(\"C:\\\\Users\\\\akunna1\\\\Desktop\\\\GEOG 592\\\\Lab_5\\\\Data.gdb\\\\LandUse\")\n",
    "\n",
    "        # Process: Distance Accumulation (Distance Accumulation) (sa)\n",
    "        Distanc_Stre1 = \"Distanc_Stre1\"\n",
    "        Distance_Accumulation = Distanc_Stre1\n",
    "        blkRaster = \"blkRaster\"\n",
    "        osdr = \"osdr\"\n",
    "        oslr = \"oslr\"\n",
    "        Distanc_Stre1 = arcpy.sa.DistanceAccumulation(in_source_data=Streams, vertical_factor=\"BINARY 1 -30 30\", horizontal_factor=\"BINARY 1 45\", out_back_direction_raster=blkRaster, out_source_direction_raster=osdr, out_source_location_raster=oslr, distance_method=\"PLANAR\")\n",
    "        Distanc_Stre1.save(Distance_Accumulation)\n",
    "\n",
    "        blkRaster = arcpy.Raster(blkRaster)\n",
    "        osdr = arcpy.Raster(osdr)\n",
    "        oslr = arcpy.Raster(oslr)\n",
    "\n",
    "        # Process: Slope (Slope) (sa)\n",
    "        Slope_Elevat1 = \"Slope_Elevat1\"\n",
    "        Slope = Slope_Elevat1\n",
    "        Slope_Elevat1 = arcpy.sa.Slope(in_raster=Elevation, output_measurement=\"DEGREE\", z_factor=0.30480060960121924, method=\"PLANAR\", z_unit=\"Foot_US\")\n",
    "        Slope_Elevat1.save(Slope)\n",
    "\n",
    "        # Process: Reclassify (Reclassify) (sa)\n",
    "        Reclass_Slop1 = \"Reclass_Slop1\"\n",
    "        Reclassify = Reclass_Slop1\n",
    "        Reclass_Slop1 = arcpy.sa.Reclassify(in_raster=Slope_Elevat1, reclass_field=\"VALUE\", remap=\"0 3 1;3 10 3;10 25 6;25 90 10\", missing_values=\"DATA\")\n",
    "        Reclass_Slop1.save(Reclassify)\n",
    "\n",
    "        # Process: Reclassify (2) (Reclassify) (sa)\n",
    "        Reclass_Land1 = \"Reclass_Land1\"\n",
    "        Reclassify_2_ = Reclass_Land1\n",
    "        Reclass_Land1 = arcpy.sa.Reclassify(in_raster=LandUse, reclass_field=\"VALUE\", remap=\"1 1;2 1;3 1;4 2;5 8;6 10;7 10;8 10;9 6;10 2;11 10;12 1\", missing_values=\"DATA\")\n",
    "        Reclass_Land1.save(Reclassify_2_)\n",
    "\n",
    "        # Process: Rescale by Function (Rescale by Function) (sa)\n",
    "        Rescale_Dist1 = \"Rescale_Dist1\"\n",
    "        Rescale_by_Function = Rescale_Dist1\n",
    "        Rescale_Dist1 = arcpy.sa.RescaleByFunction(in_raster=Distanc_Stre1, transformation_function=[[\"MSSMALL\", \"\", \"\", \"\", \"\", 1, 1, \"\"]], from_scale=1, to_scale=10)\n",
    "        Rescale_Dist1.save(Rescale_by_Function)\n",
    "\n",
    "        # Process: Raster Calculator (Raster Calculator) (sa)\n",
    "        reclas_raste = \"reclas_raste\"\n",
    "        Raster_Calculator = reclas_raste\n",
    "        reclas_raste =  Reclass_Slop1 *value0 + Reclass_Land1 *value1 + Rescale_Dist1 *value2\n",
    "        reclas_raste.save(Raster_Calculator)\n",
    "\n",
    "        arcpy.AddMessage(\"Suitable sites raster created successfully\")\n",
    "\n",
    "        return\n",
    "    \n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}