toolset to generate points in perimeter of a blocks according to distance in arcmap in toolbox

To generate points along the perimeter of blocks at specified distances using ArcMap, you can create a custom toolbox with a script tool. Here's a general approach you can take:

### Step 1: Create a New Toolbox

1. **Open ArcMap**.
2. In the **Catalog** window, right-click on any folder or a geodatabase, and select **New > Toolbox**. Name your toolbox (e.g., `GeneratePerimeterPoints.tbx`).

### Step 2: Create a Script Tool

1. Right-click on the newly created toolbox and select **Add > Script**.
2. In the **Add Script** dialog:
   - **Name**: Name your script (e.g., `GeneratePointsAlongPerimeter`).
   - **Label**: Provide a user-friendly label.
   - **Script File**: Browse and select your Python script file (which you'll create in the next step).
3. Click **Finish**.

### Step 3: Write the Python Script

Create a Python script that generates points along the perimeter of polygons based on a specified distance. Here's a simple example you can use:

```python
import arcpy

def generate_points(input_feature, distance, output_feature):
    # Create a new feature class for the output points
    arcpy.CreateFeatureclass_management(out_path=arcpy.env.workspace, out_name=output_feature, geometry_type='POINT')
    arcpy.AddField_management(output_feature, 'Distance', 'DOUBLE')

    with arcpy.da.SearchCursor(input_feature, ['SHAPE@']) as cursor:
        for row in cursor:
            geom = row[0]
            part_count = geom.partCount
            
            for part_index in range(part_count):
                part = geom.getPart(part_index)
                total_length = part.length
                
                # Generate points at specified interval
                for i in range(0, int(total_length), distance):
                    point = part.positionAlongLine(i)
                    with arcpy.da.InsertCursor(output_feature, ['SHAPE@', 'Distance']) as insert_cursor:
                        insert_cursor.insertRow([point, i])

if __name__ == '__main__':
    # Parameters
    input_features = arcpy.GetParameterAsText(0)  # Input feature class (polygons)
    distance = float(arcpy.GetParameterAsText(1))  # Distance interval for points
    output_features = arcpy.GetParameterAsText(2)  # Output feature class (points)

    generate_points(input_features, distance, output_features)

```

### Step 4: Define Parameters for the Script Tool

In the properties of your script tool:

1. Right-click the script tool and select **Properties**.
2. Go to the **Parameters** tab.
   - **Parameter 0**: Input Feature (Data Type: Feature Layer).
   - **Parameter 1**: Distance (Data Type: Double).
   - **Parameter 2**: Output Feature (Data Type: Feature Class).

### Step 5: Run the Tool

1. Open the **Toolbox** window in ArcMap.
2. Double-click your tool to run it.
3. Fill in the parameters: select the input polygon feature class, enter the distance interval, and specify the name of the output feature class.

### Additional Notes

- Make sure to check if the polygons have proper geometry (i.e., valid and closed).
- Adjust the script as needed for specific requirements, such as handling multipart geometries or specific attribute handling.
- Test the tool with a small dataset first to ensure functionality before deploying on larger datasets.

This approach provides a foundation for generating perimeter points but may require adjustments based on your specific use case or data.