how to add two point in perimeter of a polygon according to distance in arcmap with toolbox

To add two points to the perimeter of a polygon in ArcMap based on specific distances, you can follow these general steps. This process assumes you have access to ArcGIS software and are familiar with its interface, as well as how to create and run tools in a toolbox.

### Steps to Add Points to the Perimeter of a Polygon

1. **Prepare Your Data**:
   - Ensure your polygon layer is loaded in ArcMap.

2. **Create a New Toolbox**:
   - Right-click on your desired folder in ArcCatalog or ArcMap's Catalog window.
   - Select `New` > `Toolbox`.
   - Give your toolbox a meaningful name.

3. **Create a New Script Tool**:
   - Right-click on the newly created toolbox.
   - Select `Add` > `Script`.
   - Fill in the details: name your script, provide a label, and define the parameters (your polygon layer, distances for the points).

4. **Write the Python Script**:
   - Open your script editor and use the following Python script as a template:

```python
import arcpy

def add_points_to_polygon(perimeter, distance1, distance2):
    # Get the geometry of the polygon
    polygon = arcpy.Describe(perimeter).shape
    
    # Get the total length of the polygon perimeter
    total_length = polygon.length
    
    # Ensure distances are valid
    if distance1 + distance2 > total_length:
        print("Distances are greater than polygon perimeter.")
        return

    # Calculate points along the perimeter
    point1 = polygon.positionAlongLine(distance1, True)  # True returns a point with geometries
    point2 = polygon.positionAlongLine(distance1 + distance2, True)

    return point1, point2

# Input parameters
polygon_layer = arcpy.GetParameterAsText(0)  # Assume input polygon layer
distance1 = arcpy.GetParameterAsText(1)  # First distance
distance2 = arcpy.GetParameterAsText(2)  # Second distance

# Call the function to get points
points = add_points_to_polygon(polygon_layer, float(distance1), float(distance2))

# Create output feature class to store points
output_fc = "path_to_output_feature_class"  # Specify the output feature class

# Create a new feature class if it doesn't exist
if not arcpy.Exists(output_fc):
    arcpy.CreateFeatureclass_management("path_to_output_gdb", "output_fc_name", "POINT")

# Insert points into output feature class
with arcpy.da.InsertCursor(output_fc, ['SHAPE@']) as cursor:
    for point in points:
        cursor.insertRow([point])
```

5. **Set Parameters**:
   - Depending on your script, set input parameters in the properties of the script tool to allow users to input polygon layer and distances.

6. **Run the Script Tool**:
   - Save the script and open the tool in ArcMap.
   - Set your polygon layer and provide distances.
   - Run the tool and check your output location for the new points.

### Tips:
- If your polygon has complex geometry (like multi-part polygons), you might need to handle each segment individually based on your requirements.
- Adjust the script to handle exceptions, such as cases where the distances are greater than the perimeter.

### Using ArcGIS Pro:
If you're using ArcGIS Pro, the process is similar, but depending on your version, you might encounter differences in the GUI and tool settings. The core logic remains consistent.

This approach provides a systematic way to place points along a polygon's perimeter at specified distances using ArcMap's capabilities. Adjust the script according to your specific needs or geometric complexities.