introduce a toolset to add two point in perimeter of a polygon according to distance in arcmap in toolbox

Creating a custom toolset in ArcMap to add two points at specific distances along the perimeter of a polygon involves a few steps. This process typically requires a combination of geoprocessing tools and scripting with Python, particularly using the arcpy module. Here is an overview of how to design such a toolset:

### Step-by-Step Guide to Create the Toolset

#### Step 1: Create a New Toolbox
1. **Open ArcCatalog** (or the Catalog window in ArcMap).
2. **Right-click** on the location (folder) where you want to create the toolbox.
3. Select **New** > **Toolbox**.
4. Name your toolbox (e.g., "AddPointsToPolygonToolbox").

#### Step 2: Create a Custom Script Tool
1. Right-click on your new toolbox and select **Add** > **Script**.
2. Fill in the details for the script tool:
   - **Name:** AddPointsToPolygon
   - **Label:** Add Points to Polygon
   - **Description:** Adds two points along a polygon perimeter at specified distances.
3. Click **Next** to define the script file. Create a new Python script (e.g., `AddPointsToPolygon.py`), or point to an existing one.

#### Step 3: Define the Script Parameters
In the script properties, you need to define the parameters that the user will input:

1. **Input Polygon Feature Class**
   - Data Type: Feature Layer or Feature Class
   - Parameter Type: Required

2. **Distance for First Point**
   - Data Type: Double
   - Parameter Type: Required
   - Display Name: Distance to First Point

3. **Distance for Second Point**
   - Data Type: Double
   - Parameter Type: Required
   - Display Name: Distance to Second Point

4. **Output Point Feature Class**
   - Data Type: Feature Class
   - Parameter Type: Required
   - Display Name: Output Points

#### Step 4: Write the Python Script
Here is an example of what the Python script (`AddPointsToPolygon.py`) might look like:

```python
import arcpy

def add_points_to_polygon(input_polygon, distance1, distance2, output_points):
    # Create a feature class for output points
    arcpy.CreateFeatureclass_management(out_path=output_points, out_name="tmp_points", geometry_type="POINT")

    # Create a search cursor to iterate through the polygon features
    with arcpy.da.SearchCursor(input_polygon, ['SHAPE@']) as cursor:
        for row in cursor:
            polygon_shape = row[0]
            length = polygon_shape.length
            
            # Calculate relative distances along the perimeter
            point1_distance = min(distance1, length)
            point2_distance = min(distance2, length)
            
            # Create points at the specified distances
            point1 = polygon_shape.positionAlongLine(point1_distance, False)
            point2 = polygon_shape.positionAlongLine(point2_distance, False)

            # Insert points into the new feature class
            with arcpy.da.InsertCursor(output_points, ['SHAPE@']) as insert_cursor:
                insert_cursor.insertRow([point1])
                insert_cursor.insertRow([point2])

if __name__ == "__main__":
    # Get parameters from ArcMap
    input_polygon = arcpy.GetParameterAsText(0)
    distance1 = float(arcpy.GetParameterAsText(1))
    distance2 = float(arcpy.GetParameterAsText(2))
    output_points = arcpy.GetParameterAsText(3)

    # Call the function
    add_points_to_polygon(input_polygon, distance1, distance2, output_points)
```

#### Step 5: Test the Script Tool
1. Save the script and the toolbox in ArcMap.
2. Right-click the script tool in your toolbox and select **Open**.
3. Fill in the parameters with a polygon layer, the distances for the two new points, and the name for the output point feature class.
4. Run the tool and check the output to ensure it has created the points at the specified distances.

### Step 6: Customize and Enhance
- Add error handling to manage edge cases (e.g., distances greater than the polygon perimeter).
- Consider options to handle multiple polygons at once.
- Enhance user feedback and logging.

This overview should help you set up a toolset in ArcMap for adding points along a polygon's perimeter. Adjustments can be made based on specific project requirements or additional functionalities you may wish to include.